@apollo/gateway 2.0.6-rc.1 → 2.1.0-alpha.2

package/src/__tests__/executeQueryPlan.test.ts

@@ -49,8 +49,9 @@ describe('executeQueryPlan', () => {
     executeSchema?: Schema,
     executeServiceMap?: { [serviceName: string]: LocalGraphQLDataSource }
   ): Promise<GraphQLExecutionResult> {
+    const supergraphSchema = executeSchema ?? schema;
     const operationContext = buildOperationContext({
-      schema: (executeSchema ?? schema).toAPISchema().toGraphQLJSSchema(),
+      schema: supergraphSchema.toAPISchema().toGraphQLJSSchema(),
       operationDocument: gql`${operation.toString()}`,
     });
     return executeQueryPlan(
@@ -58,6 +59,7 @@ describe('executeQueryPlan', () => {
       executeServiceMap ?? serviceMap,
       executeRequestContext ?? buildRequestContext(),
       operationContext,
+      supergraphSchema.toGraphQLJSSchema(),
     );
   }
 
@@ -2738,6 +2740,202 @@ describe('executeQueryPlan', () => {
         `);
       expect(response.errors?.map((e) => e.message)).toStrictEqual(['String cannot represent value: ["invalid"]']);
     });
+
+    test('ensures type condition on inaccessible type in @require works correctly', async () => {
+      const s1 = {
+        name: 'data',
+        typeDefs: gql`
+          extend schema
+          @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key", "@shareable"])
+
+          type Entity @key(fields: "id") {
+            id: ID!
+            data: Foo
+          }
+
+          interface Foo {
+            foo: String!
+          }
+
+          interface Bar implements Foo {
+            foo: String!
+            bar: String!
+          }
+
+          type Data implements Foo & Bar @shareable {
+            foo: String!
+            bar: String!
+          }
+        `,
+        resolvers: {
+            Query: {
+              dummy() {
+                return {};
+              },
+            },
+            Entity: {
+              __resolveReference() {
+                return {};
+              },
+              id() {
+                return "id";
+              },
+              data() {
+                return {
+                  __typename: "Data",
+                  foo: "foo",
+                  bar: "bar",
+                };
+              },
+            },
+
+        }
+      }
+
+      let requirerRepresentation: any = undefined;
+
+      const s2 = {
+        name: 'requirer',
+        typeDefs: gql`
+          extend schema
+          @link(
+            url: "https://specs.apollo.dev/federation/v2.0",
+            import: ["@key", "@shareable", "@external", "@requires", "@inaccessible"]
+          )
+
+          type Query {
+            dummy: Entity
+          }
+
+          type Entity @key(fields: "id") {
+            id: ID!
+            data: Foo @external
+            requirer: String! @requires(fields: "data { foo ... on Bar { bar } }")
+          }
+
+          interface Foo {
+            foo: String!
+          }
+
+          interface Bar implements Foo @inaccessible {
+            foo: String!
+            bar: String!
+          }
+
+          type Data implements Foo & Bar @shareable {
+            foo: String!
+            bar: String!
+          }
+        `,
+        resolvers: {
+          Query: {
+            dummy() {
+              return {};
+            },
+          },
+          Entity: {
+            __resolveReference(representation: any) {
+              requirerRepresentation = representation;
+              return {};
+            },
+            id() {
+              return "id";
+            },
+            requirer() {
+              return "requirer";
+            },
+          },
+        }
+      }
+
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([ s1, s2 ]);
+
+      const operation = parseOp(`
+        query {
+          dummy {
+            requirer
+          }
+        }
+        `, schema);
+
+      const queryPlan = buildPlan(operation, queryPlanner);
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "requirer") {
+              {
+                dummy {
+                  __typename
+                  id
+                }
+              }
+            },
+            Flatten(path: "dummy") {
+              Fetch(service: "data") {
+                {
+                  ... on Entity {
+                    __typename
+                    id
+                  }
+                } =>
+                {
+                  ... on Entity {
+                    data {
+                      __typename
+                      foo
+                      ... on Data {
+                        bar
+                      }
+                    }
+                  }
+                }
+              },
+            },
+            Flatten(path: "dummy") {
+              Fetch(service: "requirer") {
+                {
+                  ... on Entity {
+                    __typename
+                    data {
+                      foo
+                      ... on Bar {
+                        bar
+                      }
+                    }
+                    id
+                  }
+                } =>
+                {
+                  ... on Entity {
+                    requirer
+                  }
+                }
+              },
+            },
+          },
+        }
+      `);
+
+      const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "dummy": Object {
+            "requirer": "requirer",
+          },
+        }
+      `);
+
+      expect(requirerRepresentation).toMatchInlineSnapshot(`
+        Object {
+          "__typename": "Entity",
+          "data": Object {
+            "bar": "bar",
+            "foo": "foo",
+          },
+          "id": "id",
+        }
+      `);
+    });
   });
 
   describe('@key', () => {

package/src/__tests__/execution-utils.ts

@@ -53,12 +53,13 @@ export async function execute(
 
   const { schema, queryPlanner } = getFederatedTestingSchema(services);
 
+  const apiSchema = schema.toAPISchema();
   const operationDocument = gql`${request.query}`;
-  const operation = operationFromDocument(schema, operationDocument);
+  const operation = operationFromDocument(apiSchema, operationDocument);
   const queryPlan = queryPlanner.buildQueryPlan(operation);
 
   const operationContext = buildOperationContext({
-    schema: schema.toAPISchema().toGraphQLJSSchema(),
+    schema: apiSchema.toGraphQLJSSchema(),
     operationDocument,
   });
 
@@ -74,6 +75,7 @@ export async function execute(
       logger
     },
     operationContext,
+    schema.toGraphQLJSSchema(),
   );
 
   return { ...result, queryPlan };
@@ -90,7 +92,7 @@ export function getFederatedTestingSchema(services: ServiceDefinitionModule[] =
     throw new GraphQLSchemaValidationError(compositionResult.errors);
   }
 
-  const queryPlanner = new QueryPlanner(compositionResult.schema);
+  const queryPlanner = new QueryPlanner(compositionResult.schema, { exposeDocumentNodeInFetchNode: false} );
   const schema = buildSchema(compositionResult.supergraphSdl);
 
   const serviceMap = Object.fromEntries(

package/src/__tests__/integration/abstract-types.test.ts

@@ -1626,14 +1626,16 @@ it('when exploding types through multiple levels', async () => {
             } =>
             {
               ... on Book {
-                reviews {
-                  body
-                }
+                ...ProductReviews
               }
               ... on Furniture {
-                reviews {
-                  body
-                }
+                ...ProductReviews
+              }
+            }
+            
+            fragment ProductReviews on Product {
+              reviews {
+                body
               }
             }
           },
@@ -1643,23 +1645,6 @@ it('when exploding types through multiple levels', async () => {
   `);
 });
 
-  // This test case describes a situation that isn't fixed by the deduplication
-  // workaround. It is here to remind us to look into this, but it doesn't
-  // actually test for the failing behavior so the test still succeeds.
-  //
-  // In cases where different possible types live in different
-  // services, you can't just merge the dependent fetches because they don't
-  // have the same parent. What you want here is to have these dependent fetches
-  // execute separately, but only take the objects fetched by its parent as input.
-  // The problem currently is that these fetches act on on the same path, so
-  // depending on the timing either one (or both) will end up fetching the same
-  // data just fetched by the other.
-  //
-  // To make this more concrete, in this case that means we'll fetch all of the
-  // reviews and authors twice.
-  //
-  // Solving this requires us to filter on the types of response objects as
-  // opposed to just collecting all objects in the path.
 it("when including the same nested fields under different type conditions that are split between services", async () => {
     const query = `#graphql
       query {
@@ -1829,63 +1814,46 @@ it("when including the same nested fields under different type conditions that a
                   }
                 },
               },
-              Flatten(path: "topProducts.@.reviews.@.author") {
-                Fetch(service: "accounts") {
-                  {
-                    ... on User {
-                      __typename
-                      id
-                    }
-                  } =>
-                  {
-                    ... on User {
-                      name
-                    }
-                  }
-                },
-              },
             },
-            Sequence {
-              Flatten(path: "topProducts.@") {
-                Fetch(service: "reviews") {
-                  {
-                    ... on TV {
-                      __typename
-                      id
-                    }
-                  } =>
-                  {
-                    ... on TV {
-                      reviews {
-                        author {
-                          __typename
-                          id
-                          username
-                        }
-                        body
+            Flatten(path: "topProducts.@") {
+              Fetch(service: "reviews") {
+                {
+                  ... on TV {
+                    __typename
+                    id
+                  }
+                } =>
+                {
+                  ... on TV {
+                    reviews {
+                      author {
+                        __typename
                         id
+                        username
                       }
-                    }
-                  }
-                },
-              },
-              Flatten(path: "topProducts.@.reviews.@.author") {
-                Fetch(service: "accounts") {
-                  {
-                    ... on User {
-                      __typename
+                      body
                       id
                     }
-                  } =>
-                  {
-                    ... on User {
-                      name
-                    }
                   }
-                },
+                }
               },
             },
           },
+          Flatten(path: "topProducts.@.reviews.@.author") {
+            Fetch(service: "accounts") {
+              {
+                ... on User {
+                  __typename
+                  id
+                }
+              } =>
+              {
+                ... on User {
+                  name
+                }
+              }
+            },
+          },
         },
       }
     `);

package/src/__tests__/integration/configuration.test.ts

@@ -1,6 +1,5 @@
 import gql from 'graphql-tag';
 import http from 'http';
-import mockedEnv from 'mocked-env';
 import type { Logger } from '@apollo/utils.logger';
 import { ApolloGateway } from '../..';
 import {
@@ -8,8 +7,6 @@ import {
   mockSupergraphSdlRequestSuccess,
   mockApolloConfig,
   mockCloudConfigUrl1,
-  mockCloudConfigUrl2,
-  mockCloudConfigUrl3,
 } from './nockMocks';
 import { getTestingSupergraphSdl } from '../execution-utils';
 import { fixtures, Fixture } from 'apollo-federation-integration-testsuite';
@@ -205,8 +202,8 @@ describe('gateway startup errors', () => {
 
     const expected =
       "A valid schema couldn't be composed. The following composition errors were found:\n"
-    + '	[accounts] On type "User", for @key(fields: "id"): Cannot query field "id" on type "User" (the field should be either be added to this subgraph or, if it should not be resolved by this subgraph, you need to add it to this subgraph with @external).\n'
-    + '	[accounts] On type "Account", for @key(fields: "id"): Cannot query field "id" on type "Account" (the field should be either be added to this subgraph or, if it should not be resolved by this subgraph, you need to add it to this subgraph with @external).'
+    + '	[accounts] On type "User", for @key(fields: "id"): Cannot query field "id" on type "User" (the field should either be added to this subgraph or, if it should not be resolved by this subgraph, you need to add it to this subgraph with @external).\n'
+    + '	[accounts] On type "Account", for @key(fields: "id"): Cannot query field "id" on type "Account" (the field should either be added to this subgraph or, if it should not be resolved by this subgraph, you need to add it to this subgraph with @external).'
     expect(err.message).toBe(expected);
   });
 });
@@ -320,46 +317,6 @@ describe('gateway config / env behavior', () => {
       );
     });
   });
-
-  describe('schema config delivery endpoint configuration', () => {
-    it('A code config overrides the env variable', async () => {
-      cleanUp = mockedEnv({
-        APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT: 'env-config',
-      });
-
-      const config = {
-        logger,
-        uplinkEndpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2, mockCloudConfigUrl3],
-      };
-      gateway = new ApolloGateway(config);
-
-      expect(gateway['getUplinkEndpoints'](config)).toEqual([
-        mockCloudConfigUrl1,
-        mockCloudConfigUrl2,
-        mockCloudConfigUrl3,
-      ]);
-
-      gateway = null;
-    });
-  });
-
-  describe('deprecated schema config delivery endpoint configuration', () => {
-    it('A code config overrides the env variable', async () => {
-      cleanUp = mockedEnv({
-        APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT: 'env-config',
-      });
-
-      const config = {
-        logger,
-        schemaConfigDeliveryEndpoint: 'code-config',
-      };
-      gateway = new ApolloGateway(config);
-
-      expect(gateway['getUplinkEndpoints'](config)).toEqual(['code-config']);
-
-      gateway = null;
-    });
-  });
 });
 
 describe('deprecation warnings', () => {