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

package/src/__tests__/executeQueryPlan.test.ts

@@ -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__/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';

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

@@ -1,6 +1,6 @@
+import { fetch } from '../../__mocks__/make-fetch-happen-fetcher';
 import { ApolloGateway } from '@apollo/gateway';
 import { ApolloServer } from 'apollo-server';
-import { fetch } from '../../__mocks__/apollo-server-env';
 import { getTestingSupergraphSdl } from '../execution-utils';
 
 async function getSupergraphSdlGatewayServer() {

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']>,

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

@@ -5,13 +5,15 @@ import gql from 'graphql-tag';
 import { buildSubgraphSchema } from '@apollo/subgraph';
 import { ApolloServer } from 'apollo-server';
 import { ApolloServerPluginUsageReporting } from 'apollo-server-core';
-import { execute, toPromise } from 'apollo-link';
-import { createHttpLink } from 'apollo-link-http';
+import { execute } from '@apollo/client/link/core';
+import { toPromise } from '@apollo/client/link/utils';
+import { createHttpLink } from '@apollo/client/link/http';
 import fetch from 'node-fetch';
 import { ApolloGateway } from '../..';
 import { Plugin, Config, Refs } from 'pretty-format';
 import { Report, Trace } from 'apollo-reporting-protobuf';
 import { fixtures } from 'apollo-federation-integration-testsuite';
+import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
 
 // Normalize specific fields that change often (eg timestamps) to static values,
 // to make snapshot testing viable.  (If these helpers are more generally
@@ -89,7 +91,6 @@ describe('reporting', () => {
   let gatewayServer: ApolloServer;
   let gatewayUrl: string;
   let reportPromise: Promise<any>;
-  let nockScope: nock.Scope;
 
   beforeEach(async () => {
     let reportResolver: (report: any) => void;
@@ -97,7 +98,8 @@ describe('reporting', () => {
       reportResolver = resolve;
     });
 
-    nockScope = nock('https://usage-reporting.api.apollographql.com')
+    nockBeforeEach();
+    nock('https://usage-reporting.api.apollographql.com')
       .post('/api/ingress/traces')
       .reply(200, (_: any, requestBody: string) => {
         reportResolver(requestBody);
@@ -137,7 +139,8 @@ describe('reporting', () => {
     if (gatewayServer) {
       await gatewayServer.stop();
     }
-    nockScope.done();
+
+    nockAfterEach();
   });
 
   it(`queries three services`, async () => {