Fetching data

1
export class ReservationsDataSource {
2
  private dbConnection;
3
  private token;
4
  private user;
5

6
  constructor(options: { token: string }) {
7
    this.dbConnection = this.initializeDBConnection();
8
    this.token = options.token;
9
  }
10

11
  async initializeDBConnection() {
12
    // set up our database details, instantiate our connection,
13
    // and return that database connection
14
    return dbConnection;
15
  }
16

17
  async getUser() {
18
    if (!this.user) {
19
      // store the user, lookup by token
20
      this.user = await this.dbConnection.User.findByToken(this.token);
21
    }
22
    return this.user;
23
  }
24

25
  async getReservation(reservationId) {
26
    const user = await this.getUser();
27
    if (user) {
28
      return await this.dbConnection.Reservation.findByPk(reservationId);
29
    } else {
30
      // handle invalid user
31
    }
32
  }
33

34
  //... more methods for finding and creating reservations
35
}

1
import DataLoader from 'dataloader';
2

3
class ProductsDataSource {
4
  private dbConnection;
5

6
  constructor(dbConnection) {
7
    this.dbConnection = dbConnection;
8
  }
9

10
  private batchProducts = new DataLoader(async (ids) => {
11
    const productList = await this.dbConnection.fetchAllKeys(ids);
12
    // Dataloader expects you to return a list with the results ordered just like the list in the arguments were
13
    // Since the database might return the results in a different order the following code sorts the results accordingly
14
    const productIdToProductMap = productList.reduce((mapping, product) => {
15
      mapping[product.id] = product;
16
      return mapping;
17
    }, {});
18
    return ids.map((id) => productIdToProductMap[id]);
19
  });
20

21
  async getProductFor(id) {
22
    return this.batchProducts.load(id);
23
  }
24
}
25

26
// In your server file
27

28
// Set up our database, instantiate our connection,
29
// and return that database connection
30
const dbConnection = initializeDBConnection();
31

32
const { url } = await startStandaloneServer(server, {
33
  context: async () => {
34
    return {
35
      dataSources: {
36
        // Create a new instance of our data source for every request!
37
        // (We pass in the database connection because we don't need
38
        // a new connection for every request.)
39
         productsDb: new ProductsDataSource(dbConnection),
40
      },
41
    };
42
  },
43
});

1
interface ContextValue {
2
  dataSources: {
3
    dogsDB: DogsDataSource;
4
    catsApi: CatsAPI;
5
  };
6
  token: string;
7
}
8

9
const server = new ApolloServer<ContextValue>({
10
  typeDefs,
11
  resolvers,
12
});
13

14
const { url } = await startStandaloneServer(server, {
15
  context: async ({ req }) => {
16
     const { cache } = server;
17
    const token = req.headers.token;
18
    return {
19
      // We create new instances of our data sources with each request.
20
      // We can pass in our server's cache, contextValue, or any other
21
      // info our data sources require.
22
      dataSources: {
23
        dogsDB: new DogsDataSource({ cache, token }),
24
        catsApi: new CatsAPI({ cache }),
25
      },
26
      token,
27
    };
28
  },
29
});
30

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

1
import { ApolloServer } from '@apollo/server';
2
import { startStandaloneServer } from '@apollo/server/standalone';
3
import { KeyValueCache } from '@apollo/utils.keyvaluecache';
4
import { Pool } from 'undici';
5
import { HTTPDataSource } from 'apollo-datasource-http';
6

7
class MoviesAPI extends HTTPDataSource {
8
  override baseURL = 'https://movies-api.example.com/';
9

10
  constructor(options: { cache: KeyValueCache<string>; token: string }) {
11
    // the necessary arguments for HTTPDataSource
12
    const pool = new Pool(baseURL);
13
    super(baseURL, { pool });
14

15
    // We need to call the initialize method in our data source's
16
    // constructor, passing in our cache and contextValue.
17
    this.initialize({ cache: options.cache, context: options.token });
18
  }
19

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

25
interface MyContext {
26
  dataSources: {
27
    moviesApi: MoviesAPI;
28
  };
29
  token?: string;
30
}
31

32
const server = new ApolloServer<MyContext>({
33
  typeDefs,
34
  resolvers,
35
});
36

37
const { url } = await startStandaloneServer(server, {
38
  context: async ({ req }) => {
39
    const { cache } = server;
40
    const token = req.headers.token;
41
    return {
42
      dataSources: {
43
        moviesApi: new MoviesAPI({ cache, token }),
44
      },
45
      token,
46
    };
47
  },
48
});