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

package/src/__tests__/executeQueryPlan.test.ts

@@ -30,11 +30,11 @@ describe('executeQueryPlan', () => {
     [serviceName: string]: LocalGraphQLDataSource;
   };
 
-  let parseOp = (operation: string, operationSchema?: Schema): Operation => {
+  const parseOp = (operation: string, operationSchema?: Schema): Operation => {
     return parseOperation((operationSchema ?? schema), operation);
   }
 
-  let buildPlan = (operation: string | Operation, operationQueryPlanner?: QueryPlanner, operationSchema?: Schema): QueryPlan => {
+  const buildPlan = (operation: string | Operation, operationQueryPlanner?: QueryPlanner, operationSchema?: Schema): QueryPlan => {
     const op = typeof operation === 'string' ? parseOp(operation, operationSchema): operation;
     return (operationQueryPlanner ?? queryPlanner).buildQueryPlan(op);
   }
@@ -88,6 +88,7 @@ describe('executeQueryPlan', () => {
   });
 
   function buildRequestContext(): GraphQLRequestContext {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     return {
       cache: undefined as any,
@@ -1116,102 +1117,409 @@ describe('executeQueryPlan', () => {
     });
   });
 
-  it('can query other subgraphs when the Query type is the type of a field', async () => {
-    const s1 = gql`
-      type Query {
-        getA: A
-      }
+  describe('reusing root types', () => {
+    it('can query other subgraphs when the Query type is the type of a field', async () => {
+      const s1 = gql`
+        type Query {
+          getA: A
+        }
 
-      type A {
-        q: Query
-      }
-    `;
+        type A {
+          q: Query
+        }
+      `;
 
-    const s2 = gql`
-      type Query {
-        one: Int
-      }
-    `;
+      const s2 = gql`
+        type Query {
+          one: Int
+        }
+      `;
 
-    const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([
-      { name: 'S1', typeDefs: s1 },
-      { name: 'S2', typeDefs: s2 }
-    ]);
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([
+        { name: 'S1', typeDefs: s1 },
+        { name: 'S2', typeDefs: s2 }
+      ]);
 
-    addResolversToSchema(serviceMap['S1'].schema, {
-      Query: {
-        getA() {
-          return {
-            getA: {
-              q: null
-            }
-          };
+      addResolversToSchema(serviceMap['S1'].schema, {
+        Query: {
+          getA() {
+            return {
+              getA: {}
+            };
+          },
         },
-      },
-      A: {
-        q() {
-          return Object.create(null);
+        A: {
+          q() {
+            return Object.create(null);
+          }
         }
-      }
-    });
+      });
 
-    addResolversToSchema(serviceMap['S2'].schema, {
-      Query: {
-        one() {
-          return 1;
+      addResolversToSchema(serviceMap['S2'].schema, {
+        Query: {
+          one() {
+            return 1;
+          },
         },
-      },
-    });
+      });
 
-    const operation = parseOp(`
-      query {
-        getA {
-          q {
-            one
+      const operation = parseOp(`
+        query {
+          getA {
+            q {
+              one
+            }
           }
         }
-      }
-      `, schema);
+        `, schema);
 
-    const queryPlan = buildPlan(operation, queryPlanner);
+      const queryPlan = buildPlan(operation, queryPlanner);
 
-    expect(queryPlan).toMatchInlineSnapshot(`
-      QueryPlan {
-        Sequence {
-          Fetch(service: "S1") {
-            {
-              getA {
-                q {
-                  __typename
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "S1") {
+              {
+                getA {
+                  q {
+                    __typename
+                  }
                 }
               }
+            },
+            Flatten(path: "getA.q") {
+              Fetch(service: "S2") {
+                {
+                  ... on Query {
+                    one
+                  }
+                }
+              },
+            },
+          },
+        }
+        `);
+
+      const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "getA": Object {
+            "q": Object {
+              "one": 1,
+            },
+          },
+        }
+      `);
+    })
+
+    it('can query other subgraphs when the Query type is the type of a field after a mutation', async () => {
+        const s1 = gql`
+          type Query {
+            one: Int
+          }
+
+          type Mutation {
+            mutateSomething: Query
+          }
+        `;
+
+        const s2 = gql`
+          type Query {
+            two: Int
+          }
+        `;
+
+        const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([
+          { name: 'S1', typeDefs: s1 },
+          { name: 'S2', typeDefs: s2 }
+        ]);
+
+        let hasMutated = false;
+
+        addResolversToSchema(serviceMap['S1'].schema, {
+          Query: {
+            one() {
+              return 1;
+            },
+          },
+          Mutation: {
+            mutateSomething() {
+              hasMutated = true;
+              return {};
+            },
+          }
+        });
+
+        addResolversToSchema(serviceMap['S2'].schema, {
+          Query: {
+            two() {
+              return 2;
+            },
+          },
+        });
+
+        const operation = parseOp(`
+          mutation {
+            mutateSomething {
+              one
+              two
             }
+          }
+          `, schema);
+
+        const queryPlan = buildPlan(operation, queryPlanner);
+
+        expect(queryPlan).toMatchInlineSnapshot(`
+          QueryPlan {
+            Sequence {
+              Fetch(service: "S1") {
+                {
+                  mutateSomething {
+                    __typename
+                    one
+                  }
+                }
+              },
+              Flatten(path: "mutateSomething") {
+                Fetch(service: "S2") {
+                  {
+                    ... on Query {
+                      two
+                    }
+                  }
+                },
+              },
+            },
+          }
+        `);
+
+        const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+
+        expect(hasMutated).toBeTruthy();
+        expect(response.data).toMatchInlineSnapshot(`
+          Object {
+            "mutateSomething": Object {
+              "one": 1,
+              "two": 2,
+            },
+          }
+        `);
+    })
+
+    it('can mutate other subgraphs when the Mutation type is the type of a field', async () => {
+      const s1 = gql`
+        type Query {
+          getA: A
+        }
+
+        type Mutation {
+          mutateOne: Int
+        }
+
+        type A {
+          m: Mutation
+        }
+      `;
+
+      const s2 = gql`
+        type Mutation {
+          mutateTwo: Int
+        }
+      `;
+
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([
+        { name: 'S1', typeDefs: s1 },
+        { name: 'S2', typeDefs: s2 }
+      ]);
+
+      let mutateOneCalled = false;
+      let mutateTwoCalled = false;
+
+      addResolversToSchema(serviceMap['S1'].schema, {
+        Query: {
+          getA() {
+            return {
+              getA: {}
+            };
           },
-          Flatten(path: "getA.q") {
-            Fetch(service: "S2") {
+        },
+        A: {
+          m() {
+            return Object.create(null);
+          }
+        },
+        Mutation: {
+          mutateOne() {
+            mutateOneCalled = true;
+            return 1;
+          }
+        }
+      });
+
+      addResolversToSchema(serviceMap['S2'].schema, {
+        Mutation: {
+          mutateTwo() {
+            mutateTwoCalled = true;
+            return 2;
+          },
+        },
+      });
+
+      const operation = parseOp(`
+        query {
+          getA {
+            m {
+              mutateOne
+              mutateTwo
+            }
+          }
+        }
+        `, schema);
+
+      const queryPlan = buildPlan(operation, queryPlanner);
+
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "S1") {
               {
-                ... on Query {
-                  one
+                getA {
+                  m {
+                    __typename
+                    mutateOne
+                  }
                 }
               }
             },
+            Flatten(path: "getA.m") {
+              Fetch(service: "S2") {
+                {
+                  ... on Mutation {
+                    mutateTwo
+                  }
+                }
+              },
+            },
           },
-        },
-      }
-    `);
-
-    const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+        }
+      `);
 
-    expect(response.data).toMatchInlineSnapshot(`
-      Object {
-        "getA": Object {
-          "q": Object {
-            "one": 1,
+      const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      expect(mutateOneCalled).toBeTruthy();
+      expect(mutateTwoCalled).toBeTruthy();
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "getA": Object {
+            "m": Object {
+              "mutateOne": 1,
+              "mutateTwo": 2,
+            },
           },
-        },
-      }
+        }
       `);
-  })
+    })
+
+    it('can mutate other subgraphs when the Mutation type is the type of a field after a mutation', async () => {
+        const s1 = gql`
+          type Query {
+            one: Int
+          }
+
+          type Mutation {
+            mutateSomething: Mutation
+          }
+        `;
+
+        const s2 = gql`
+          type Mutation {
+            mutateTwo: Int
+          }
+        `;
+
+        const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([
+          { name: 'S1', typeDefs: s1 },
+          { name: 'S2', typeDefs: s2 }
+        ]);
+
+        let somethingMutationCount = 0;
+        let hasMutatedTwo = false;
+
+        addResolversToSchema(serviceMap['S1'].schema, {
+          Query: {
+            one() {
+              return 1;
+            },
+          },
+          Mutation: {
+            mutateSomething() {
+              ++somethingMutationCount;
+              return {};
+            },
+          }
+        });
+
+        addResolversToSchema(serviceMap['S2'].schema, {
+          Mutation: {
+            mutateTwo() {
+              hasMutatedTwo = true;
+              return 2;
+            },
+          },
+        });
+
+        const operation = parseOp(`
+          mutation {
+            mutateSomething {
+              mutateSomething {
+                mutateTwo
+              }
+            }
+          }
+          `, schema);
+
+        const queryPlan = buildPlan(operation, queryPlanner);
+
+        expect(queryPlan).toMatchInlineSnapshot(`
+          QueryPlan {
+            Sequence {
+              Fetch(service: "S1") {
+                {
+                  mutateSomething {
+                    mutateSomething {
+                      __typename
+                    }
+                  }
+                }
+              },
+              Flatten(path: "mutateSomething.mutateSomething") {
+                Fetch(service: "S2") {
+                  {
+                    ... on Mutation {
+                      mutateTwo
+                    }
+                  }
+                },
+              },
+            },
+          }
+        `);
+
+        const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+
+        expect(somethingMutationCount).toBe(2);
+        expect(hasMutatedTwo).toBeTruthy();
+        expect(response.data).toMatchInlineSnapshot(`
+          Object {
+            "mutateSomething": Object {
+              "mutateSomething": Object {
+                "mutateTwo": 2,
+              },
+            },
+          }
+        `);
+    })
+  });
 
   describe('interfaces on interfaces', () => {
     it('can execute queries on an interface only implemented by other interfaces', async () => {
@@ -1309,7 +1617,7 @@ describe('executeQueryPlan', () => {
         },
       });
 
-      let operation = parseOp(`
+      const operation = parseOp(`
         query {
           allValues {
             a
@@ -1323,7 +1631,7 @@ describe('executeQueryPlan', () => {
         }
         `, schema);
 
-      let queryPlan = buildPlan(operation, queryPlanner);
+      const queryPlan = buildPlan(operation, queryPlanner);
 
       expect(queryPlan).toMatchInlineSnapshot(`
         QueryPlan {
@@ -1378,7 +1686,7 @@ describe('executeQueryPlan', () => {
         }
       `);
 
-      let response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
 
       expect(response.data).toMatchInlineSnapshot(`
         Object {
@@ -1642,4 +1950,192 @@ describe('executeQueryPlan', () => {
         `);
     });
   });
+
+  test('do not send subgraphs an interface they do not know', async () => {
+    // This test validates that the issue described on https://github.com/apollographql/federation/issues/817 is fixed.
+    const s1 = {
+      name: 'S1',
+      typeDefs: gql`
+        type Query {
+          myField: MyInterface
+        }
+
+        interface MyInterface {
+          name: String
+        }
+
+        type MyTypeA implements MyInterface {
+          name: String
+        }
+
+        type MyTypeB implements MyInterface {
+          name: String
+        }
+      `
+    }
+
+    const s2 = {
+      name: 'S2',
+      typeDefs: gql`
+        interface MyInterface {
+          name: String
+        }
+
+        type MyTypeC implements MyInterface {
+          name: String
+        }
+      `
+    }
+
+    const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([ s1, s2 ]);
+
+    addResolversToSchema(serviceMap['S1'].schema, {
+      Query: {
+        myField() {
+          return { __typename: 'MyTypeA', name: "foo" };
+        },
+      },
+    });
+
+    // First, we just query the field without conditions.
+    // Note that there is no reason to type-explode this: clearly, `myField` will never return a `MyTypeC` since
+    // it's resolved by S1 which doesn't know that type, but that doesn't impact the plan.
+    let operation = parseOp(`
+      query {
+        myField {
+          name
+        }
+      }
+      `, schema);
+    let queryPlan = buildPlan(operation, queryPlanner);
+    expect(queryPlan).toMatchInlineSnapshot(`
+      QueryPlan {
+        Fetch(service: "S1") {
+          {
+            myField {
+              __typename
+              name
+            }
+          }
+        },
+      }
+    `);
+    let response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+    expect(response.data).toMatchInlineSnapshot(`
+      Object {
+        "myField": Object {
+          "name": "foo",
+        },
+      }
+      `);
+
+    // Now forcing the query planning to notice that `MyTypeC` can never happen and making
+    // sure it doesn't ask it from S1, which doesn't know it.
+    operation = parseOp(`
+      query {
+        myField {
+          ... on MyTypeA {
+            name
+          }
+          ... on MyTypeC {
+            name
+          }
+        }
+      }
+      `, schema);
+    queryPlan = buildPlan(operation, queryPlanner);
+    expect(queryPlan).toMatchInlineSnapshot(`
+      QueryPlan {
+        Fetch(service: "S1") {
+          {
+            myField {
+              __typename
+              ... on MyTypeA {
+                name
+              }
+            }
+          }
+        },
+      }
+    `);
+
+    response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+    expect(response.data).toMatchInlineSnapshot(`
+      Object {
+        "myField": Object {
+          "name": "foo",
+        },
+      }
+      `);
+
+
+    // Testing only getting name for `MyTypeB`, which is known by S1, but not returned
+    // by `myField` in practice (so the result is "empty").
+    operation = parseOp(`
+      query {
+        myField {
+          ... on MyTypeB {
+            name
+          }
+        }
+      }
+      `, schema);
+
+    queryPlan = buildPlan(operation, queryPlanner);
+    expect(queryPlan).toMatchInlineSnapshot(`
+      QueryPlan {
+        Fetch(service: "S1") {
+          {
+            myField {
+              __typename
+              ... on MyTypeB {
+                name
+              }
+            }
+          }
+        },
+      }
+    `);
+    response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+    expect(response.data).toMatchInlineSnapshot(`
+      Object {
+        "myField": Object {},
+      }
+      `);
+
+    operation = parseOp(`
+      query {
+        myField {
+          ... on MyTypeC {
+            name
+          }
+        }
+      }
+      `, schema);
+
+    // Lastly, same with only getting name for `MyTypeC`. It isn't known by S1 so the condition should not
+    // be included in the query, but we should still query `myField` to know if it resolve to "something"
+    // (and all we know it can't be a `MyTypeC`) or to `null`. In particular, the end response should be
+    // the same than in the previous example with `MyTypeB` since from the end-use POV, this is the same
+    // example.
+    queryPlan = buildPlan(operation, queryPlanner);
+    expect(queryPlan).toMatchInlineSnapshot(`
+      QueryPlan {
+        Fetch(service: "S1") {
+          {
+            myField {
+              __typename
+            }
+          }
+        },
+      }
+    `);
+
+    response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+    expect(response.data).toMatchInlineSnapshot(`
+      Object {
+        "myField": Object {},
+      }
+      `);
+  });
 });