与 AWS Lambda 部署

1
import { ApolloServer } from '@apollo/server';
2

3
// The GraphQL schema
4
const typeDefs = `#graphql
5
  type Query {
6
    hello: String
7
  }
8
`;
9

10
// A map of functions which return data for the schema.
11
const resolvers = {
12
  Query: {
13
    hello: () => 'world',
14
  },
15
};
16

17
// Set up Apollo Server
18
const server = new ApolloServer({
19
  typeDefs,
20
  resolvers,
21
});

1
import { ApolloServer } from '@apollo/server';
2
import { startServerAndCreateLambdaHandler, handlers } from '@as-integrations/aws-lambda';
3

4
const typeDefs = `#graphql
5
  type Query {
6
    hello: String
7
  }
8
`;
9

10
const resolvers = {
11
  Query: {
12
    hello: () => 'world',
13
  },
14
};
15

16
const server = new ApolloServer({
17
  typeDefs,
18
  resolvers,
19
});
20

21
// This final export is important!
22
export const graphqlHandler = startServerAndCreateLambdaHandler(
23
  server,
24
  // We will be using the Proxy V2 handler
25
  handlers.createAPIGatewayProxyEventV2RequestHandler(),
26
);

1
import { middleware, startServerAndCreateLambdaHandler, handlers } from '@as-integrations/aws-lambda';
2
import { server } from './server';
3

4
const requestHandler = handlers.createAPIGatewayProxyEventV2RequestHandler();
5

6
// Middleware is an async function whose type is based on your request handler. Middleware
7
// can read and mutate the incoming event. Additionally, returning an async function from your
8
// middleware allows you to read and mutate the result before it's sent.
9
const middlewareFn: middleware.MiddlewareFn<typeof requestHandler> = async (event) => {
10
  // read or update the event here
11
  // optionally return a callback to access the result
12
  return async (result) => {
13
    // read or update the result here
14
  };
15
};
16

17
startServerAndCreateLambdaHandler(server, requestHandler, {
18
  middleware: [middlewareFn],
19
});

1
import { startServerAndCreateLambdaHandler, middleware, handlers } from '@as-integrations/aws-lambda';
2
import type { APIGatewayProxyEventV2WithLambdaAuthorizer } from 'aws-lambda';
3
import { server } from './server';
4

5
export default startServerAndCreateLambdaHandler(
6
  server,
7
  handlers.createAPIGatewayProxyEventV2RequestHandler<
8
    APIGatewayProxyEventV2WithLambdaAuthorizer<{
9
      myAuthorizerContext: string;
10
    }>
11
  >(),
12
);

1
import { startServerAndCreateLambdaHandler, handlers } from '@as-integrations/aws-lambda';
2
import type { APIGatewayProxyEventV2 } from 'aws-lambda';
3
import { HeaderMap } from '@apollo/server';
4
import { server } from './server';
5

6
type CustomInvokeEvent = {
7
  httpMethod: string;
8
  queryParams: string;
9
  headers: Record<string, string>;
10
  body: string;
11
};
12

13
type CustomInvokeResult =
14
  | {
15
      success: true;
16
      body: string;
17
    }
18
  | {
19
      success: false;
20
      error: string;
21
    };
22

23
const requestHandler = handlers.createRequestHandler<CustomInvokeEvent, CustomInvokeResult>(
24
  {
25
    parseHttpMethod(event) {
26
      return event.httpMethod;
27
    },
28
    parseHeaders(event) {
29
      const headerMap = new HeaderMap();
30
      for (const [key, value] of Object.entries(event.headers)) {
31
        headerMap.set(key, value);
32
      }
33
      return headerMap;
34
    },
35
    parseQueryParams(event) {
36
      return event.queryParams;
37
    },
38
    parseBody(event) {
39
      return event.body;
40
    },
41
  },
42
  {
43
    success({ body }) {
44
      return {
45
        success: true,
46
        body: body.string,
47
      };
48
    },
49
    error(e) {
50
      if (e instanceof Error) {
51
        return {
52
          success: false,
53
          error: e.toString(),
54
        };
55
      }
56
      console.error('Unknown error type encountered!', e);
57
      throw e;
58
    },
59
  },
60
);
61

62
export default startServerAndCreateLambdaHandler(server, requestHandler);

1
const server = new ApolloServer<MyContext>({
2
  typeDefs,
3
  resolvers,
4
});
5

6
// This final export is important!
7
export const graphqlHandler = startServerAndCreateLambdaHandler(server, handlers.createAPIGatewayProxyEventV2RequestHandler(), {
8
  context: async ({ event, context }) => {
9
    return {
10
      lambdaEvent: event,
11
      lambdaContext: context,
12
    };
13
  },
14
});

1
const { ApolloServer } = require('@apollo/server');
2
const { expressMiddleware } = require('@apollo/server/express4');
3
const serverlessExpress = require('@vendia/serverless-express');
4
const express = require('express');
5
const cors = require('cors');
6

7
const server = new ApolloServer({
8
  typeDefs: 'type Query { x: ID }',
9
  resolvers: { Query: { x: () => 'hi!' } },
10
});
11

12
server.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
13

14
const app = express();
15
app.use(
16
  cors(),
17
  express.json(),
18
  expressMiddleware(server, {
19
    // The Express request and response objects are passed into
20
    // your context initialization function
21
    context: async ({ req, res }) => {
22
      // Here is where you'll have access to the
23
      // API Gateway event and Lambda Context
24
      const { event, context } = serverlessExpress.getCurrentInvoke();
25
      return {
26
        expressRequest: req,
27
        expressResponse: res,
28
        lambdaEvent: event,
29
        lambdaContext: context,
30
      };
31
    },
32
  }),
33
);
34

35
exports.handler = serverlessExpress({ app });

1
const { ApolloServer } = require('@apollo/server');
2
const { expressMiddleware } = require('@apollo/server/express4');
3
const serverlessExpress = require('@vendia/serverless-express');
4
const express = require('express');
5
const cors = require('cors');
6

7
const server = new ApolloServer({
8
  typeDefs: 'type Query { x: ID }',
9
  resolvers: { Query: { x: () => 'hi!' } },
10
});
11

12
server.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
13

14
const app = express();
15
app.use(cors(), express.json(), expressMiddleware(server));
16

17
exports.graphqlHandler = serverlessExpress({ app });