迁移到 Apollo Server 4

1
// npm install apollo-server graphql
2
import { ApolloServer } from 'apollo-server';
3
import { typeDefs, resolvers } from './schema';
4

5
interface MyContext {
6
  token?: String;
7
}
8

9
const server = new ApolloServer({
10
  typeDefs,
11
  resolvers,
12
  context: async ({ req }) => ({ token: req.headers.token }),
13
});
14
const { url } = await server.listen(4000);
15
console.log(`🚀  Server ready at ${url}`);

1
// npm install @apollo/server graphql
2
import { ApolloServer } from '@apollo/server';
3
import { startStandaloneServer } from '@apollo/server/standalone';
4
import { typeDefs, resolvers } from './schema';
5

6
interface MyContext {
7
  token?: String;
8
}
9

10
const server = new ApolloServer<MyContext>({ typeDefs, resolvers });
11
const { url } = await startStandaloneServer(server, {
12
  context: async ({ req }) => ({ token: req.headers.token }),
13
  listen: { port: 4000 },
14
});
15
console.log(`🚀  Server ready at ${url}`);

1
// npm install apollo-server-express apollo-server-core express graphql
2
import { ApolloServer } from 'apollo-server-express';
3
import { ApolloServerPluginDrainHttpServer } from 'apollo-server-core';
4
import express from 'express';
5
import http from 'http';
6
import { typeDefs, resolvers } from './schema';
7

8
interface MyContext {
9
  token?: String;
10
}
11

12
const app = express();
13
const httpServer = http.createServer(app);
14
const server = new ApolloServer({
15
  typeDefs,
16
  resolvers,
17
  context: async ({ req }) => ({ token: req.headers.token }),
18
  plugins: [ApolloServerPluginDrainHttpServer({ httpServer })],
19
});
20
await server.start();
21
server.applyMiddleware({ app });
22
await new Promise<void>((resolve) => httpServer.listen({ port: 4000 }, resolve));
23
console.log(`🚀 Server ready at https://127.0.0.1:4000${server.graphqlPath}`);

1
// npm install @apollo/server express graphql cors
2
import { ApolloServer } from '@apollo/server';
3
import { expressMiddleware } from '@apollo/server/express4';
4
import { ApolloServerPluginDrainHttpServer } from '@apollo/server/plugin/drainHttpServer';
5
import express from 'express';
6
import http from 'http';
7
import cors from 'cors';
8
import { typeDefs, resolvers } from './schema';
9

10
interface MyContext {
11
  token?: String;
12
}
13

14
const app = express();
15
const httpServer = http.createServer(app);
16
const server = new ApolloServer<MyContext>({
17
  typeDefs,
18
  resolvers,
19
  plugins: [ApolloServerPluginDrainHttpServer({ httpServer })],
20
});
21
await server.start();
22
app.use(
23
  '/graphql',
24
  cors<cors.CorsRequest>(),
25
  express.json(),
26
  expressMiddleware(server, {
27
    context: async ({ req }) => ({ token: req.headers.token }),
28
  }),
29
);
30

31
await new Promise<void>((resolve) => httpServer.listen({ port: 4000 }, resolve));
32
console.log(`🚀 Server ready at https://127.0.0.1:4000/graphql`);

1
new ApolloServer({
2
  // ...
3
  status400ForVariableCoercionErrors: true,
4
});

1
import { RESTDataSource, RequestOptions } from 'apollo-datasource-rest';
2
import { ApolloServer } from 'apollo-server';
3

4
class MoviesAPI extends RESTDataSource {
5
  override baseURL = 'https://movies-api.example.com/';
6

7
  override willSendRequest(request: RequestOptions) {
8
    request.headers.set('Authorization', this.context.token);
9
  }
10

11
  async getMovie(id: string): Promise<Movie> {
12
    return this.get<Movie>(`movies/${encodeURIComponent(id)}`);
13
  }
14

15
  async updateMovie(movie: Movie): Promise<Movie> {
16
    return this.patch(
17
      'movies',
18
      // Syntax for passing a request body
19
       { id: movie.id, movie },
20
    );
21
  }
22
}
23

24
interface ContextValue {
25
  token: string;
26
  dataSources: {
27
    moviesAPI: MoviesAPI;
28
  };
29
}
30

31
const server = new ApolloServer({
32
  typeDefs,
33
  resolvers,
34
  context: ({ req: ExpressRequest }): Omit<ContextValue, 'dataSources'> => {
35
    return {
36
      token: getTokenFromRequest(req),
37
    };
38
  },
39
  dataSources: (): ContextValue['dataSources'] => {
40
    return {
41
      moviesAPI: new MoviesAPI(),
42
    };
43
  },
44
});
45

46
await server.listen();

1
import { RESTDataSource, AugmentedRequest } from '@apollo/datasource-rest';
2
// KeyValueCache is the type of Apollo server's default cache
3
import type { KeyValueCache } from '@apollo/utils.keyvaluecache';
4
import { ApolloServer } from '@apollo/server';
5
import { startStandaloneServer } from '@apollo/server/standalone';
6

7
 class MoviesAPI extends RESTDataSource {
8
  override baseURL = 'https://movies-api.example.com/';
9
  private token: string;
10

11
  constructor(options: { token: string; cache: KeyValueCache }) {
12
    super(options); // this sends our server's `cache` through
13
    this.token = options.token;
14
  }
15

16
  override willSendRequest(path: string, request: AugmentedRequest) {
17
    request.headers.authorization = this.token;
18
  }
19

20
  async getMovie(id: string): Promise<Movie> {
21
    return this.get<Movie>(`movies/${encodeURIComponent(id)}`);
22
  }
23

24
  async updateMovie(movie: Movie): Promise<Movie> {
25
    return this.patch(
26
      'movies',
27
      // Note the way we pass request bodies has also changed!
28
       { body: { id: movie.id, movie } },
29
    );
30
  }
31
}
32
interface ContextValue {
33
  token: string;
34
  dataSources: {
35
    moviesAPI: MoviesAPI;
36
  };
37
}
38

39
const server = new ApolloServer<ContextValue>({
40
  typeDefs,
41
  resolvers,
42
});
43

44
const { url } = await startStandaloneServer(server, {
45
  context: async ({ req }) => {
46
    const token = getTokenFromRequest(req);
47
    const { cache } = server;
48
    return {
49
      token,
50
      dataSources: {
51
        moviesAPI: new MoviesAPI({ cache, token }),
52
      },
53
    };
54
  },
55
});
56

57
console.log(`🚀  Server ready at ${url}`);

1
 import { RESTDataSource, WillSendRequestOptions } from '@apollo/datasource-rest';
2
import { KeyValueCache } from '@apollo/utils.keyvaluecache';
3
import { ApolloServer } from '@apollo/server';
4
import { startStandaloneServer } from '@apollo/server/standalone';
5
import { IncomingMessage } from 'http';
6

7
class MoviesAPI extends RESTDataSource {
8
  override baseURL = 'https://movies-api.example.com/';
9
  private contextValue: ContextValue;
10

11
  constructor(options: { contextValue: ContextValue; cache: KeyValueCache }) {
12
    super(options); // this should send `cache` through
13
    this.contextValue = options.contextValue;
14
  }
15

16
  override willSendRequest(path: string, request: WillSendRequestOptions) {
17
    request.headers['authorization'] = this.contextValue.token;
18
  }
19

20
  async getMovie(id): Promise<Movie> {
21
    return this.get<Movie>(`movies/${encodeURIComponent(id)}`);
22
  }
23
}
24

25
class ContextValue {
26
  public token: string;
27
  public dataSources: {
28
    moviesAPI: MoviesAPI;
29
  };
30

31
  constructor({ req, server }: { req: IncomingMessage; server: ApolloServer<ContextValue> }) {
32
    this.token = getTokenFromRequest(req);
33
    const { cache } = server;
34
    this.dataSources = {
35
      moviesAPI: new MoviesAPI({ cache, contextValue: this }),
36
    };
37
  }
38
}
39

40
const server = new ApolloServer<ContextValue>({
41
  typeDefs,
42
  resolvers,
43
});
44

45
await startStandaloneServer(server, {
46
   context: async ({ req }) => new ContextValue({ req, server }),
47
});