@apollo/gateway 2.3.4 → 2.3.6

package/src/__tests__/executeQueryPlan.introspection.test.ts

@@ -0,0 +1,140 @@
+import gql from 'graphql-tag';
+import { getFederatedTestingSchema, ServiceDefinitionModule } from './execution-utils';
+import { Operation, parseOperation, Schema } from "@apollo/federation-internals";
+import { QueryPlan } from '@apollo/query-planner';
+import { LocalGraphQLDataSource } from '../datasources';
+import { GatewayExecutionResult, GatewayGraphQLRequestContext } from '@apollo/server-gateway-interface';
+import { buildOperationContext } from '../operationContext';
+import { executeQueryPlan } from '../executeQueryPlan';
+
+function buildRequestContext(variables: Record<string, any>): GatewayGraphQLRequestContext {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  return {
+    cache: undefined as any,
+    context: {},
+    request: {
+      variables,
+    },
+    metrics: {},
+  };
+}
+
+async function executePlan(
+  queryPlan: QueryPlan,
+  operation: Operation,
+  schema: Schema,
+  serviceMap: { [serviceName: string]: LocalGraphQLDataSource },
+  variables: Record<string, any> = {},
+): Promise<GatewayExecutionResult> {
+  const apiSchema = schema.toAPISchema();
+  const operationContext = buildOperationContext({
+    schema: apiSchema.toGraphQLJSSchema(),
+    operationDocument: gql`${operation.toString()}`,
+  });
+  return executeQueryPlan(
+    queryPlan,
+    serviceMap,
+    buildRequestContext(variables),
+    operationContext,
+    schema.toGraphQLJSSchema(),
+    apiSchema,
+  );
+}
+
+describe('handling of introspection queries', () => {
+  const typeDefs: ServiceDefinitionModule[] = [
+    {
+      name: 'S1',
+      typeDefs: gql`
+        type Query {
+          t: [T]
+        }
+
+        interface T {
+          id: ID!
+        }
+
+        type T1 implements T @key(fields: "id") {
+          id: ID!
+          a1: Int
+        }
+
+        type T2 implements T @key(fields: "id") {
+          id: ID!
+          a2: Int
+        }
+      `,
+    },
+  ];
+  const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema(typeDefs);
+
+  it('it handles aliases on introspection fields', async () => {
+    const operation = parseOperation(schema, `
+      {
+        myAlias: __type(name: "T1") {
+          kind
+          name
+        }
+      }
+    `);
+
+    const queryPlan = queryPlanner.buildQueryPlan(operation);
+    const response = await executePlan(queryPlan, operation, schema, serviceMap);
+    expect(response.errors).toBeUndefined();
+    expect(response.data).toMatchInlineSnapshot(`
+      Object {
+        "myAlias": Object {
+          "kind": "OBJECT",
+          "name": "T1",
+        },
+      }
+    `);
+  });
+
+  it('it handles aliases inside introspection fields', async () => {
+    const operation = parseOperation(schema, `
+      {
+        __type(name: "T1") {
+          myKind: kind
+          name
+        }
+      }
+    `);
+
+    const queryPlan = queryPlanner.buildQueryPlan(operation);
+    const response = await executePlan(queryPlan, operation, schema, serviceMap);
+    expect(response.errors).toBeUndefined();
+    expect(response.data).toMatchInlineSnapshot(`
+      Object {
+        "__type": Object {
+          "myKind": "OBJECT",
+          "name": "T1",
+        },
+      }
+    `);
+  });
+
+  it('it handles variables passed to introspection fields', async () => {
+    const operation = parseOperation(schema, `
+      query ($name: String!) {
+        __type(name: $name) {
+          kind
+          name
+        }
+      }
+    `);
+
+    const queryPlan = queryPlanner.buildQueryPlan(operation);
+    const response = await executePlan(queryPlan, operation, schema, serviceMap, { name: "T1" });
+    expect(response.errors).toBeUndefined();
+    expect(response.data).toMatchInlineSnapshot(`
+      Object {
+        "__type": Object {
+          "kind": "OBJECT",
+          "name": "T1",
+        },
+      }
+    `);
+  });
+});

package/src/__tests__/executeQueryPlan.test.ts

@@ -4587,6 +4587,514 @@ describe('executeQueryPlan', () => {
         }
       `);
     });
+
+    test('handles querying @interfaceObject from a specific implementation', async () => {
+      const s1 = {
+        name: 's1',
+        typeDefs: gql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key"])
+
+          type Query {
+            ts: [T!]!
+          }
+
+          interface I {
+            id: ID!
+          }
+
+          type T implements I @key(fields: "id") {
+            id: ID!
+          }
+        `,
+        resolvers: {
+          Query: {
+            ts: () => [ { id: '2' }, { id: '4' }, { id: '1' } ]
+          },
+        }
+      }
+
+      const s2 = {
+        name: 's2',
+        typeDefs: gql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key", "@interfaceObject", "@external", "@requires"])
+
+          type I @key(fields: "id") @interfaceObject {
+            id: ID!
+            v: String
+          }
+        `,
+        resolvers: {
+          I: {
+            __resolveReference(ref: any) {
+              return {
+                ...ref,
+                v: `id=${ref.id}`
+              };
+            },
+          }
+        }
+      }
+
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([ s1, s2 ]);
+
+      let operation = parseOp(`
+        {
+          ts {
+            v
+          }
+        }
+        `, schema);
+
+      let queryPlan = buildPlan(operation, queryPlanner);
+      const expectedPlan = `
+        QueryPlan {
+          Sequence {
+            Fetch(service: "s1") {
+              {
+                ts {
+                  __typename
+                  id
+                }
+              }
+            },
+            Flatten(path: "ts.@") {
+              Fetch(service: "s2") {
+                {
+                  ... on T {
+                    __typename
+                    id
+                  }
+                } =>
+                {
+                  ... on I {
+                    v
+                  }
+                }
+              },
+            },
+          },
+        }
+      `;
+      expect(queryPlan).toMatchInlineSnapshot(expectedPlan);
+
+      let response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "ts": Array [
+            Object {
+              "v": "id=2",
+            },
+            Object {
+              "v": "id=4",
+            },
+            Object {
+              "v": "id=1",
+            },
+          ],
+        }
+      `);
+    });
+
+    test('handles querying @interfaceObject from a specific implementation (even when the subgraph does not have the corresponding interface)', async () => {
+      const s1 = {
+        name: 's1',
+        typeDefs: gql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key"])
+
+          type Query {
+            ts: [T!]!
+          }
+
+          type T @key(fields: "id", resolvable: false) {
+            id: ID!
+          }
+        `,
+        resolvers: {
+          Query: {
+            ts: () => [ { id: '2' }, { id: '4' }, { id: '1' } ]
+          },
+        }
+      }
+
+      const s2 = {
+        name: 's2',
+        typeDefs: gql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key", "@interfaceObject"])
+
+          interface I @key(fields: "id") {
+            id: ID!
+            required: String
+          }
+
+          type T implements I @key(fields: "id") {
+            id: ID!
+            required: String
+          }
+
+        `,
+        resolvers: {
+          I: {
+            __resolveReference(ref: any) {
+              return [
+                { id: '1', __typename: "T", required: "r1" },
+                { id: '2', __typename: "T", required: "r2" },
+                { id: '3', __typename: "T", required: "r3" },
+                { id: '4', __typename: "T", required: "r4" },
+              ].find(({id}) => id === ref.id);
+            },
+          },
+        }
+      }
+
+      const s3 = {
+        name: 's3',
+        typeDefs: gql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key", "@interfaceObject", "@external", "@requires"])
+
+          type I @key(fields: "id") @interfaceObject {
+            id: ID!
+            required: String @external
+            v: String @requires(fields: "required")
+          }
+        `,
+        resolvers: {
+          I: {
+            __resolveReference(ref: any) {
+              return {
+                ...ref,
+                v: `req=${ref.required}`
+              };
+            },
+          }
+        }
+      }
+
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([ s1, s2, s3 ]);
+
+      let operation = parseOp(`
+        {
+          ts {
+            v
+          }
+        }
+        `, schema);
+
+      let queryPlan = buildPlan(operation, queryPlanner);
+      const expectedPlan = `
+        QueryPlan {
+          Sequence {
+            Fetch(service: "s1") {
+              {
+                ts {
+                  __typename
+                  id
+                }
+              }
+            },
+            Flatten(path: "ts.@") {
+              Fetch(service: "s2") {
+                {
+                  ... on I {
+                    __typename
+                    id
+                  }
+                } =>
+                {
+                  ... on I {
+                    __typename
+                    required
+                  }
+                }
+              },
+            },
+            Flatten(path: "ts.@") {
+              Fetch(service: "s3") {
+                {
+                  ... on I {
+                    __typename
+                    required
+                    id
+                  }
+                } =>
+                {
+                  ... on I {
+                    v
+                  }
+                }
+              },
+            },
+          },
+        }
+      `;
+      expect(queryPlan).toMatchInlineSnapshot(expectedPlan);
+
+      let response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "ts": Array [
+            Object {
+              "v": "req=r2",
+            },
+            Object {
+              "v": "req=r4",
+            },
+            Object {
+              "v": "req=r1",
+            },
+          ],
+        }
+      `);
+    });
+
+    test('handles @requires on @interfaceObject that applies to only one of the queried implementation', async () => {
+      // The case this test is that where the @interfaceObject in s2 has a @requires, but the query we send requests the field on which
+      // there is this @require only for one of the implementation type, which it request another field with no require for another implementation.
+      // And we're making sure the requirements only get queried for T1, the first type.
+      const s1 = {
+        name: 's1',
+        typeDefs: gql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key"])
+
+          type Query {
+            is: [I!]!
+          }
+
+          interface I @key(fields: "id") {
+            id: ID!
+            name: String
+            req: Req
+          }
+
+          type T1 implements I @key(fields: "id") {
+            id: ID!
+            name: String
+            req: Req
+          }
+
+          type T2 implements I @key(fields: "id") {
+            id: ID!
+            name: String
+            req: Req
+          }
+
+          type Req {
+            id: ID!
+          }
+        `,
+        resolvers: {
+          Query: {
+            is: () => [
+              { __typename: 'T1', id: '2', name: 'e2', req: { id: 'r1'} },
+              { __typename: 'T2', id: '4', name: 'e4', req: { id: 'r2'} },
+              { __typename: 'T1', id: '1', name: 'e1', req: { id: 'r3'} }
+            ]
+          },
+        }
+      }
+
+      const s2 = {
+        name: 's2',
+        typeDefs: gql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key", "@interfaceObject", "@external", "@requires"])
+
+          type I @key(fields: "id") @interfaceObject {
+            id: ID!
+            req: Req @external
+            v: String! @requires(fields: "req { id }")
+          }
+
+          type Req {
+            id: ID! @external
+          }
+        `,
+        resolvers: {
+          I: {
+            __resolveReference(ref: any) {
+              return {
+                ...ref,
+                v: `req=${ref.req.id}`
+              };
+            },
+          }
+        }
+      }
+
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([ s1, s2 ]);
+
+      let operation = parseOp(`
+        {
+          is {
+            ... on T1 {
+              v
+            }
+            ... on T2 {
+              name
+            }
+          }
+        }
+        `, schema);
+
+      let queryPlan = buildPlan(operation, queryPlanner);
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "s1") {
+              {
+                is {
+                  __typename
+                  ... on T1 {
+                    __typename
+                    id
+                    req {
+                      id
+                    }
+                  }
+                  ... on T2 {
+                    name
+                  }
+                }
+              }
+            },
+            Flatten(path: "is.@") {
+              Fetch(service: "s2") {
+                {
+                  ... on T1 {
+                    __typename
+                    id
+                  }
+                  ... on I {
+                    __typename
+                    req {
+                      id
+                    }
+                  }
+                } =>
+                {
+                  ... on I {
+                    v
+                  }
+                }
+              },
+            },
+          },
+        }
+      `);
+
+      let response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      expect(response.errors).toBeUndefined();
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "is": Array [
+            Object {
+              "v": "req=r1",
+            },
+            Object {
+              "name": "e4",
+            },
+            Object {
+              "v": "req=r3",
+            },
+          ],
+        }
+      `);
+
+      // Sanity checking that if we ask for `v` (the field with @requires), then everything still works.
+      operation = parseOp(`
+        {
+          is {
+            ... on T1 {
+              v
+            }
+            ... on T2 {
+              v
+              name
+            }
+          }
+        }
+        `, schema);
+
+      global.console = require('console');
+      queryPlan = buildPlan(operation, queryPlanner);
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "s1") {
+              {
+                is {
+                  __typename
+                  ... on T1 {
+                    __typename
+                    id
+                    req {
+                      id
+                    }
+                  }
+                  ... on T2 {
+                    __typename
+                    id
+                    req {
+                      id
+                    }
+                    name
+                  }
+                }
+              }
+            },
+            Flatten(path: "is.@") {
+              Fetch(service: "s2") {
+                {
+                  ... on T1 {
+                    __typename
+                    id
+                  }
+                  ... on I {
+                    __typename
+                    req {
+                      id
+                    }
+                  }
+                  ... on T2 {
+                    __typename
+                    id
+                  }
+                } =>
+                {
+                  ... on I {
+                    v
+                  }
+                }
+              },
+            },
+          },
+        }
+      `);
+
+      response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      expect(response.errors).toBeUndefined();
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "is": Array [
+            Object {
+              "v": "req=r1",
+            },
+            Object {
+              "name": "e4",
+              "v": "req=r2",
+            },
+            Object {
+              "v": "req=r3",
+            },
+          ],
+        }
+      `);
+    });
   });
 
   describe('fields with conflicting types needing aliasing', () => {