TypeScript GraphQLServer.start方法代码示例

  context: req => ({
    ...req,
    jwtSecret: JWT_SECRET,
    faker,
    pubsub
  })
});

server.express.disable('x-powered-by');

server.express.use(
  '/graphql',
  jwt({
    secret: JWT_SECRET,
    credentialsRequired: false
  })
);

server.express.use(compression());

const options = {
  formatError,
  endpoint: '/graphql',
  subscriptions: '/subscriptions',
  playground: '/'
};

server.start(options, ({ port }) =>
  console.log(`Server is running on PORT: ${port}`)
);

import { GraphQLServer } from 'graphql-yoga'
import { prisma } from './generated/prisma-client'
import { resolvers } from './resolvers'

const server = new GraphQLServer({
  typeDefs: './src/schema.graphql',
  resolvers,
  context: {
    prisma,
  },
} as any)

server.start(() => console.log('Server is running on http://localhost:4000'))

import { GraphQLServer } from "graphql-yoga";
import { default as typeDefs } from './typeDefs'
import { default as resolvers } from './resolvers'

const options = { port: 4004 };

const server = new GraphQLServer({
  typeDefs,
  resolvers
});

server.start(options, () =>
  console.log(`Server is running ⚡ on localhost:${options.port}`))
  .catch(err => console.error('connection Error', err));

  secret: process.env.PRISMA_SECRET, // taken from database/prisma.yml (value is set in .env)
  debug: true, // log all GraphQL queries & mutations
});

export const server = new GraphQLServer({
  typeDefs: './src/schema.graphql',
  resolvers,
  context: req => ({
    ...req,
    db,
    mailer,
    stripe,
  }),
});

server.start(options, () => console.log(`Server is running on http://localhost:4000`));

const rawBodyParser = require('body-parser').raw({ type: '*/*' });

server.express.post('/stripe', rawBodyParser, async (req, res, next) => {
  let data;
  // Check if webhook signing is configured.
  if (process.env.STRIPE_WEBHOOK_SECRET) {
    // Retrieve the event by verifying the signature using the raw body and secret.
    let event;
    let signature = req.headers['stripe-signature'];
    try {
      event = stripe.webhooks.constructEvent(
        req.body,
        signature,
        process.env.STRIPE_WEBHOOK_SECRET,

export const startServer = async () => {
   
  const server = new GraphQLServer({ 
    schema : genSchema(),
    context: ({ request }) => ({ 
      redis,
      url: `${request.protocol}://${request.get("host")}`,
      session: request.session // req now has a session to it
    })
  });

  // add express-server middleware
  server.express.use(
    session({
      store: new RedisStore({
        client: redis as any
      }),
      name: "qid",
      secret: process.env.SESSION_SECRET as string,
      resave: false,
      saveUninitialized: false,
      cookie: {
        httpOnly: true,
        secure: process.env.NODE_ENV === "production",
        maxAge: 1000 * 60 * 60 * 24 * 7 // 7 days
      }
    })
  );
  // server.express.use(
  //   // session options
  //   session({
  //     store: new RedisStore({
  //       client: redis as any
  //     }),
  //     name: "qid",
  //     secret: 'secret',
  //     resave: false,
  //     saveUninitialized: false, // dont store cookie unless data on user needs to be added
  //     cookie: { // cookie settings
  //       httpOnly: true, // JS cannot access cookie --> security
  //       secure: process.env.NODE_ENV === "production",
  //       maxAge: 1000 * 60 * 60 * 24 * 7 // 7 days
  //     }
  //   })
  // );

  // send a cookie back
  const cors = {
    credentials: true,
    origin: process.env.NODE_ENV === "test" 
      ? '*' 
      : process.env.FRONTEND_HOST as string // front end server host
  }

  // REST endpoint for email confirmation link
  // Once user clicks on confirmation link
  server.express.get("/confirm/:id", confirmEmail);
  
  await createTypeormConn();
  const app = await server.start({
    cors, 
    port: process.env.NODE_ENV === 'test' ? 0 : 4000 
  });
  console.log('Server is running on localhost:4000');

  return app;
}

import { GraphQLServer } from 'graphql-yoga';

const typeDefs = `
  type Query {
    greet: String
  }
`

const resolvers = {
  Query: {
    greet: () => 'hello world'
  }
}

const server = new GraphQLServer({typeDefs, resolvers})
server.start(() => console.log('⚡️  Waiting to greet you at http://localhost:4000'))