@apollo/gateway 2.0.0-alpha.2 → 2.0.0-alpha.6

package/src/__tests__/executeQueryPlan.test.ts

@@ -4,7 +4,6 @@ import {
   GraphQLObjectType,
   print,
 } from 'graphql';
-import { addResolversToSchema, GraphQLResolverMap } from 'apollo-graphql';
 import gql from 'graphql-tag';
 import { GraphQLExecutionResult, GraphQLRequestContext } from 'apollo-server-types';
 import { AuthenticationError } from 'apollo-server-core';
@@ -21,6 +20,7 @@ import { ApolloGateway } from '..';
 import { ApolloServerBase as ApolloServer } from 'apollo-server-core';
 import { getFederatedTestingSchema } from './execution-utils';
 import { Schema, Operation, parseOperation, buildSchemaFromAST } from '@apollo/federation-internals';
+import { addResolversToSchema, GraphQLResolverMap } from '../schema-helper';
 
 expect.addSnapshotSerializer(astSerializer);
 expect.addSnapshotSerializer(queryPlanSerializer);
@@ -2138,4 +2138,602 @@ describe('executeQueryPlan', () => {
       }
       `);
   });
+
+  describe('@requires', () => {
+    test('handles null in required field correctly (with nullable fields)', async () => {
+      const s1_data = [
+        { id: 0, f1: "foo" },
+        { id: 1, f1: null },
+        { id: 2, f1: "bar" },
+      ];
+
+      const s1 = {
+        name: 'S1',
+        typeDefs: gql`
+          type T1 @key(fields: "id") {
+            id: Int!
+            f1: String
+          }
+        `,
+        resolvers: {
+          T1: {
+            __resolveReference(ref: {id: number}) {
+              return s1_data[ref.id];
+            },
+          },
+        }
+      }
+
+      const s2 = {
+        name: 'S2',
+        typeDefs: gql`
+          type Query {
+            getT1s: [T1]
+          }
+
+          type T1 @key(fields: "id") {
+            id: Int!
+            f1: String @external
+            f2: T2 @requires(fields: "f1")
+          }
+
+          type T2 {
+            a: String
+          }
+        `,
+        resolvers: {
+          Query: {
+            getT1s() {
+              return [{id: 0}, {id: 1}, {id: 2}];
+            },
+          },
+          T1: {
+            __resolveReference(ref: { id: number }) {
+              // the ref has already the id and f1 is a require is triggered, and we resolve f2 below
+              return ref;
+            },
+            f2(o: { f1: string }) {
+              return o.f1 === null ? null : { a: `t1:${o.f1}` };
+            }
+          }
+        }
+      }
+
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([ s1, s2 ]);
+
+      const operation = parseOp(`
+        query {
+          getT1s {
+            id
+            f1
+            f2 {
+              a
+            }
+          }
+        }
+        `, schema);
+      const queryPlan = buildPlan(operation, queryPlanner);
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "S2") {
+              {
+                getT1s {
+                  __typename
+                  id
+                }
+              }
+            },
+            Flatten(path: "getT1s.@") {
+              Fetch(service: "S1") {
+                {
+                  ... on T1 {
+                    __typename
+                    id
+                  }
+                } =>
+                {
+                  ... on T1 {
+                    f1
+                  }
+                }
+              },
+            },
+            Flatten(path: "getT1s.@") {
+              Fetch(service: "S2") {
+                {
+                  ... on T1 {
+                    __typename
+                    f1
+                    id
+                  }
+                } =>
+                {
+                  ... on T1 {
+                    f2 {
+                      a
+                    }
+                  }
+                }
+              },
+            },
+          },
+        }
+      `);
+      const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "getT1s": Array [
+            Object {
+              "f1": "foo",
+              "f2": Object {
+                "a": "t1:foo",
+              },
+              "id": 0,
+            },
+            Object {
+              "f1": null,
+              "f2": null,
+              "id": 1,
+            },
+            Object {
+              "f1": "bar",
+              "f2": Object {
+                "a": "t1:bar",
+              },
+              "id": 2,
+            },
+          ],
+        }
+        `);
+      expect(response.errors).toBeUndefined();
+    });
+
+    test('handles null in required field correctly (with @require field non-nullable)', async () => {
+      const s1_data = [
+        { id: 0, f1: "foo" },
+        { id: 1, f1: null },
+        { id: 2, f1: "bar" },
+      ];
+
+      const s1 = {
+        name: 'S1',
+        typeDefs: gql`
+          type T1 @key(fields: "id") {
+            id: Int!
+            f1: String
+          }
+        `,
+        resolvers: {
+          T1: {
+            __resolveReference(ref: { id: number }) {
+              return s1_data[ref.id];
+            },
+          },
+        }
+      }
+
+      const s2 = {
+        name: 'S2',
+        typeDefs: gql`
+          type Query {
+            getT1s: [T1]
+          }
+
+          type T1 @key(fields: "id") {
+            id: Int!
+            f1: String @external
+            f2: T2! @requires(fields: "f1")
+          }
+
+          type T2 {
+            a: String
+          }
+        `,
+        resolvers: {
+          Query: {
+            getT1s() {
+              return [{id: 0}, {id: 1}, {id: 2}];
+            },
+          },
+          T1: {
+            __resolveReference(ref: { id: number }) {
+              // the ref has already the id and f1 is a require is triggered, and we resolve f2 below
+              return ref;
+            },
+            f2(o: { f1: string }) {
+              return o.f1 === null ? null : { a: `t1:${o.f1}` };
+            }
+          }
+        }
+      }
+
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([ s1, s2 ]);
+
+      const operation = parseOp(`
+        query {
+          getT1s {
+            id
+            f1
+            f2 {
+              a
+            }
+          }
+        }
+        `, schema);
+      const queryPlan = buildPlan(operation, queryPlanner);
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "S2") {
+              {
+                getT1s {
+                  __typename
+                  id
+                }
+              }
+            },
+            Flatten(path: "getT1s.@") {
+              Fetch(service: "S1") {
+                {
+                  ... on T1 {
+                    __typename
+                    id
+                  }
+                } =>
+                {
+                  ... on T1 {
+                    f1
+                  }
+                }
+              },
+            },
+            Flatten(path: "getT1s.@") {
+              Fetch(service: "S2") {
+                {
+                  ... on T1 {
+                    __typename
+                    f1
+                    id
+                  }
+                } =>
+                {
+                  ... on T1 {
+                    f2 {
+                      a
+                    }
+                  }
+                }
+              },
+            },
+          },
+        }
+      `);
+
+      const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      // `null` should bubble up since `f2` is now non-nullable. But we should still get the `id: 0` response.
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "getT1s": Array [
+            Object {
+              "f1": "foo",
+              "f2": Object {
+                "a": "t1:foo",
+              },
+              "id": 0,
+            },
+            null,
+            Object {
+              "f1": "bar",
+              "f2": Object {
+                "a": "t1:bar",
+              },
+              "id": 2,
+            },
+          ],
+        }
+        `);
+
+      // We returning `null` for f2 which isn't nullable, so it bubbled up and we should have an error
+      expect(response.errors?.map((e) => e.message)).toStrictEqual(['Cannot return null for non-nullable field T1.f2.']);
+    });
+
+    test('handles null in required field correctly (with non-nullable required field)', async () => {
+      const s1 = {
+        name: 'S1',
+        typeDefs: gql`
+          type T1 @key(fields: "id") {
+            id: Int!
+            f1: String!
+          }
+        `,
+        resolvers: {
+          T1: {
+            __resolveReference(ref: { id: number}) {
+              return s1_data[ref.id];
+            },
+          },
+        }
+      }
+
+      const s2 = {
+        name: 'S2',
+        typeDefs: gql`
+          type Query {
+            getT1s: [T1]
+          }
+
+          type T1 @key(fields: "id") {
+            id: Int!
+            f1: String! @external
+            f2: T2 @requires(fields: "f1")
+          }
+
+          type T2 {
+            a: String
+          }
+        `,
+        resolvers: {
+          Query: {
+            getT1s() {
+              return [{id: 0}, {id: 1}, {id: 2}];
+            },
+          },
+          T1: {
+            __resolveReference(ref: { id: number }) {
+              // the ref has already the id and f1 is a require is triggered, and we resolve f2 below
+              return ref;
+            },
+            f2(o: { f1: string }) {
+              return o.f1 === null ? null : { a: `t1:${o.f1}` };
+            }
+          }
+        }
+      }
+
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([ s1, s2 ]);
+
+      const s1_data = [
+        { id: 0, f1: "foo" },
+        { id: 1, f1: null },
+        { id: 2, f1: "bar" },
+      ];
+
+      const operation = parseOp(`
+        query {
+          getT1s {
+            id
+            f1
+            f2 {
+              a
+            }
+          }
+        }
+        `, schema);
+      const queryPlan = buildPlan(operation, queryPlanner);
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "S2") {
+              {
+                getT1s {
+                  __typename
+                  id
+                }
+              }
+            },
+            Flatten(path: "getT1s.@") {
+              Fetch(service: "S1") {
+                {
+                  ... on T1 {
+                    __typename
+                    id
+                  }
+                } =>
+                {
+                  ... on T1 {
+                    f1
+                  }
+                }
+              },
+            },
+            Flatten(path: "getT1s.@") {
+              Fetch(service: "S2") {
+                {
+                  ... on T1 {
+                    __typename
+                    f1
+                    id
+                  }
+                } =>
+                {
+                  ... on T1 {
+                    f2 {
+                      a
+                    }
+                  }
+                }
+              },
+            },
+          },
+        }
+      `);
+
+      const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      // `null` should bubble up since `f2` is now non-nullable. But we should still get the `id: 0` response.
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "getT1s": Array [
+            Object {
+              "f1": "foo",
+              "f2": Object {
+                "a": "t1:foo",
+              },
+              "id": 0,
+            },
+            null,
+            Object {
+              "f1": "bar",
+              "f2": Object {
+                "a": "t1:bar",
+              },
+              "id": 2,
+            },
+          ],
+        }
+        `);
+      expect(response.errors?.map((e) => e.message)).toStrictEqual(['Cannot return null for non-nullable field T1.f1.']);
+    });
+
+    test('handles errors in required field correctly (with nullable fields)', async () => {
+      const s1 = {
+        name: 'S1',
+        typeDefs: gql`
+          type T1 @key(fields: "id") {
+            id: Int!
+            f1: String
+          }
+        `,
+        resolvers: {
+          T1: {
+            __resolveReference(ref: { id: number }) {
+              return ref;
+            },
+            f1(o: { id: number }) {
+              switch (o.id) {
+                case 0: return "foo";
+                case 1: return [ "invalid" ]; // This will effectively throw
+                case 2: return "bar";
+                default: throw new Error('Not handled');
+              }
+            }
+          },
+        }
+      }
+
+      const s2 = {
+        name: 'S2',
+        typeDefs: gql`
+          type Query {
+            getT1s: [T1]
+          }
+
+          type T1 @key(fields: "id") {
+            id: Int!
+            f1: String @external
+            f2: T2 @requires(fields: "f1")
+          }
+
+          type T2 {
+            a: String
+          }
+        `,
+        resolvers: {
+          Query: {
+            getT1s() {
+              return [{id: 0}, {id: 1}, {id: 2}];
+            },
+          },
+          T1: {
+            __resolveReference(ref: { id: number }) {
+              // the ref has already the id and f1 is a require is triggered, and we resolve f2 below
+              return ref;
+            },
+            f2(o: { f1: string }) {
+              return o.f1 === null ? null : { a: `t1:${o.f1}` };
+            }
+          }
+        }
+      }
+
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([ s1, s2 ]);
+
+      const operation = parseOp(`
+        query {
+          getT1s {
+            id
+            f1
+            f2 {
+              a
+            }
+          }
+        }
+        `, schema);
+      const queryPlan = buildPlan(operation, queryPlanner);
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "S2") {
+              {
+                getT1s {
+                  __typename
+                  id
+                }
+              }
+            },
+            Flatten(path: "getT1s.@") {
+              Fetch(service: "S1") {
+                {
+                  ... on T1 {
+                    __typename
+                    id
+                  }
+                } =>
+                {
+                  ... on T1 {
+                    f1
+                  }
+                }
+              },
+            },
+            Flatten(path: "getT1s.@") {
+              Fetch(service: "S2") {
+                {
+                  ... on T1 {
+                    __typename
+                    f1
+                    id
+                  }
+                } =>
+                {
+                  ... on T1 {
+                    f2 {
+                      a
+                    }
+                  }
+                }
+              },
+            },
+          },
+        }
+      `);
+      const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "getT1s": Array [
+            Object {
+              "f1": "foo",
+              "f2": Object {
+                "a": "t1:foo",
+              },
+              "id": 0,
+            },
+            Object {
+              "f1": null,
+              "f2": null,
+              "id": 1,
+            },
+            Object {
+              "f1": "bar",
+              "f2": Object {
+                "a": "t1:bar",
+              },
+              "id": 2,
+            },
+          ],
+        }
+        `);
+      expect(response.errors?.map((e) => e.message)).toStrictEqual(['String cannot represent value: ["invalid"]']);
+    });
+  });
 });

package/src/__tests__/execution-utils.ts

@@ -2,7 +2,7 @@ import {
   GraphQLSchemaValidationError,
   GraphQLSchemaModule,
   GraphQLResolverMap,
-} from 'apollo-graphql';
+} from '../schema-helper';
 import { GraphQLRequest, GraphQLExecutionResult, Logger } from 'apollo-server-types';
 import { buildSubgraphSchema } from '@apollo/subgraph';
 import {
@@ -109,8 +109,8 @@ export function getTestingSupergraphSdl(services: typeof fixtures = fixtures) {
   throw new Error(`Testing fixtures don't compose properly!\nCauses:\n${compositionResult.errors.join('\n\n')}`);
 }
 
-export function wait(ms: number) {
-  return new Promise(r => setTimeout(r, ms));
+export function wait(ms: number, toResolveTo?: any) {
+  return new Promise((r) => setTimeout(() => r(toResolveTo), ms));
 }
 
 export function printPlan(queryPlan: QueryPlan): string {

package/src/__tests__/gateway/buildService.test.ts

@@ -1,4 +1,4 @@
-import { fetch } from '../../__mocks__/apollo-server-env';
+import { fetch } from '../../__mocks__/make-fetch-happen-fetcher';
 import { ApolloServerBase as ApolloServer } from 'apollo-server-core';
 
 import { RemoteGraphQLDataSource } from '../../datasources/RemoteGraphQLDataSource';
@@ -218,7 +218,7 @@ it('does not share service definition cache between gateways', async () => {
           url: 'https://api.example.com/repeat',
         },
       ],
-      experimental_didUpdateComposition: updateObserver,
+      experimental_didUpdateSupergraph: updateObserver,
     });
 
     await gateway.load();
@@ -237,7 +237,7 @@ it('does not share service definition cache between gateways', async () => {
           url: 'https://api.example.com/repeat',
         },
       ],
-      experimental_didUpdateComposition: updateObserver,
+      experimental_didUpdateSupergraph: updateObserver,
     });
 
     await gateway.load();

package/src/__tests__/gateway/endToEnd.test.ts

@@ -1,10 +1,10 @@
-import { GraphQLSchemaModule } from 'apollo-graphql';
 import { buildSubgraphSchema } from '@apollo/subgraph';
 import { ApolloServer } from 'apollo-server';
 import fetch from 'node-fetch';
 import { ApolloGateway } from '../..';
 import { fixtures } from 'apollo-federation-integration-testsuite';
 import { ApolloServerPluginInlineTrace } from 'apollo-server-core';
+import { GraphQLSchemaModule } from '../../schema-helper';
 
 async function startFederatedServer(modules: GraphQLSchemaModule[]) {
   const schema = buildSubgraphSchema(modules);

package/src/__tests__/gateway/executor.test.ts

@@ -1,8 +1,8 @@
+import { fetch } from '../../__mocks__/make-fetch-happen-fetcher';
 import gql from 'graphql-tag';
 import { ApolloGateway } from '../../';
 import { fixtures } from 'apollo-federation-integration-testsuite';
 import { Logger } from 'apollo-server-types';
-import { fetch } from '../../__mocks__/apollo-server-env';
 
 let logger: {
   warn: jest.MockedFunction<Logger['warn']>,