feat(utils): makeExtendSchemaPlugin interfaces support (#696)

benjie · web-flow · commit 8af9ed5afa14 · 2020-11-28T09:25:42.000Z
diff --git a/packages/graphile-build/src/SchemaBuilder.d.ts b/packages/graphile-build/src/SchemaBuilder.d.ts
@@ -14,6 +14,7 @@ import {
   GraphQLInputFieldConfigMap,
   GraphQLInputFieldConfig,
   GraphQLUnionTypeConfig,
+  GraphQLInterfaceTypeConfig,
 } from "graphql";
 import { EventEmitter } from "events";
 
@@ -182,6 +183,34 @@ export default class SchemaBuilder extends EventEmitter {
     before?: Array<string>,
     after?: Array<string>
   ): void;
+  hook<TSource, TContext>(
+    hookName: "GraphQLInterfaceType",
+    fn: Hook<GraphQLInterfaceTypeConfig<TSource, TContext>>,
+    provides?: Array<string>,
+    before?: Array<string>,
+    after?: Array<string>
+  ): void;
+  hook<TSource, TContext>(
+    hookName: "GraphQLInterfaceType:fields",
+    fn: Hook<GraphQLFieldConfigMap<TSource, TContext>>,
+    provides?: Array<string>,
+    before?: Array<string>,
+    after?: Array<string>
+  ): void;
+  hook<TSource, TContext>(
+    hookName: "GraphQLInterfaceType:fields:field",
+    fn: Hook<GraphQLFieldConfig<TSource, TContext>>,
+    provides?: Array<string>,
+    before?: Array<string>,
+    after?: Array<string>
+  ): void;
+  hook(
+    hookName: "GraphQLInterfaceType:fields:field:args",
+    fn: Hook<GraphQLFieldConfigArgumentMap>,
+    provides?: Array<string>,
+    before?: Array<string>,
+    after?: Array<string>
+  ): void;
   hook(
     hookName: "finalize",
     fn: Hook<GraphQLSchema>,
diff --git a/packages/graphile-build/src/SchemaBuilder.js b/packages/graphile-build/src/SchemaBuilder.js
@@ -231,6 +231,19 @@ class SchemaBuilder extends EventEmitter {
       // - 'GraphQLUnionType:types' to add additional types to this union
       GraphQLUnionType: [],
       "GraphQLUnionType:types": [],
+
+      // When creating a GraphQLInterfaceType via `newWithHooks`, we'll
+      // execute, the following hooks:
+      // - 'GraphQLInterfaceType' to add any root-level attributes, e.g. add a description
+      // - 'GraphQLInterfaceType:fields' to add additional fields to this interface type (is
+      //   ran asynchronously and gets a reference to the final GraphQL Interface as
+      //   `Self` in the context)
+      // - 'GraphQLInterfaceType:fields:field' to customise an individual field from above
+      // - 'GraphQLInterfaceType:fields:field:args' to customize the arguments to a field
+      GraphQLInterfaceType: [],
+      "GraphQLInterfaceType:fields": [],
+      "GraphQLInterfaceType:fields:field": [],
+      "GraphQLInterfaceType:fields:field:args": [],
     };
   }
 
diff --git a/packages/graphile-build/src/makeNewBuild.js b/packages/graphile-build/src/makeNewBuild.js
@@ -860,6 +860,126 @@ export default function makeNewBuild(builder: SchemaBuilder): { ...Build } {
             );
           },
         };
+      } else if (Type === GraphQLInterfaceType) {
+        const commonContext = {
+          type: "GraphQLInterfaceType",
+          scope,
+        };
+        newSpec = builder.applyHooks(
+          this,
+          "GraphQLInterfaceType",
+          newSpec,
+          commonContext,
+          `|${newSpec.name}`
+        );
+
+        const rawSpec = newSpec;
+        newSpec = {
+          ...newSpec,
+          fields: () => {
+            const processedFields = [];
+            const fieldsContext = {
+              ...commonContext,
+              Self,
+              GraphQLInterfaceType: rawSpec,
+              fieldWithHooks: ((fieldName, spec, fieldScope) => {
+                if (!isString(fieldName)) {
+                  throw new Error(
+                    "It looks like you forgot to pass the fieldName to `fieldWithHooks`, we're sorry this is currently necessary."
+                  );
+                }
+                if (!fieldScope) {
+                  throw new Error(
+                    "All calls to `fieldWithHooks` must specify a `fieldScope` " +
+                      "argument that gives additional context about the field so " +
+                      "that further plugins may more easily understand the field. " +
+                      "Keys within this object should contain the phrase 'field' " +
+                      "since they will be merged into the parent objects scope and " +
+                      "are not allowed to clash. If you really have no additional " +
+                      "information to give, please just pass `{}`."
+                  );
+                }
+
+                let newSpec = spec;
+                const context = {
+                  ...commonContext,
+                  Self,
+                  scope: extend(
+                    extend(
+                      { ...scope },
+                      {
+                        fieldName,
+                      },
+                      `Within context for GraphQLInterfaceType '${rawSpec.name}'`
+                    ),
+                    fieldScope,
+                    `Extending scope for field '${fieldName}' within context for GraphQLInterfaceType '${rawSpec.name}'`
+                  ),
+                };
+                if (typeof newSpec === "function") {
+                  newSpec = newSpec(context);
+                }
+                newSpec = builder.applyHooks(
+                  this,
+                  "GraphQLInterfaceType:fields:field",
+                  newSpec,
+                  context,
+                  `|${getNameFromType(Self)}.fields.${fieldName}`
+                );
+                newSpec.args = newSpec.args || {};
+                newSpec = {
+                  ...newSpec,
+                  args: builder.applyHooks(
+                    this,
+                    "GraphQLInterfaceType:fields:field:args",
+                    newSpec.args,
+                    {
+                      ...context,
+                      field: newSpec,
+                      returnType: newSpec.type,
+                    },
+                    `|${getNameFromType(Self)}.fields.${fieldName}`
+                  ),
+                };
+                const finalSpec = newSpec;
+                processedFields.push(finalSpec);
+                return finalSpec;
+              }: FieldWithHooksFunction),
+            };
+            let rawFields = rawSpec.fields || {};
+            if (typeof rawFields === "function") {
+              rawFields = rawFields(fieldsContext);
+            }
+            const fieldsSpec = builder.applyHooks(
+              this,
+              "GraphQLInterfaceType:fields",
+              this.extend(
+                {},
+                rawFields,
+                `Default field included in newWithHooks call for '${
+                  rawSpec.name
+                }'. ${inScope.__origin || ""}`
+              ),
+              fieldsContext,
+              `|${rawSpec.name}`
+            );
+            // Finally, check through all the fields that they've all been processed; any that have not we should do so now.
+            for (const fieldName in fieldsSpec) {
+              const fieldSpec = fieldsSpec[fieldName];
+              if (processedFields.indexOf(fieldSpec) < 0) {
+                // We've not processed this yet; process it now!
+                fieldsSpec[fieldName] = fieldsContext.fieldWithHooks(
+                  fieldName,
+                  fieldSpec,
+                  {
+                    autoField: true, // We don't have any additional information
+                  }
+                );
+              }
+            }
+            return fieldsSpec;
+          },
+        };
       }
 
       const finalSpec: ConfigType = newSpec;
diff --git a/packages/graphile-utils/__tests__/ExtendSchemaPlugin.test.js b/packages/graphile-utils/__tests__/ExtendSchemaPlugin.test.js
@@ -795,3 +795,109 @@ it("supports defining a simple subscription", async () => {
   expect(done).toBeTruthy();
   expect(value).toBe(undefined);
 });
+
+it("supports interfaces and unions", async () => {
+  const schema = await buildSchema([
+    ...simplePlugins,
+    makeExtendSchemaPlugin(_build => ({
+      typeDefs: gql`
+        interface Named {
+          name: String!
+        }
+
+        type A implements Named {
+          name: String!
+          a: Int!
+        }
+        type B implements Named {
+          name(suffix: String): String!
+          b: Int!
+        }
+        type C {
+          c: Int!
+        }
+
+        union ABC = A | B | C
+        extend type Query {
+          abc: [ABC!]
+          named: [Named!]
+        }
+
+        extend interface Named {
+          nameLanguage: String
+        }
+        extend type A {
+          nameLanguage: String
+        }
+        extend type B {
+          nameLanguage: String
+        }
+      `,
+      resolvers: {
+        Query: {
+          abc: () => [
+            { name: "A-one", a: 1, nameLanguage: "en" },
+            { name: "B-two", b: 2, nameLanguage: "en" },
+            { c: 3 },
+          ],
+          named: () => [
+            { name: "A-one", a: 1, nameLanguage: "en" },
+            { name: "B-two", b: 2, nameLanguage: "en" },
+          ],
+        },
+        ABC: {
+          __resolveType(obj) {
+            if (obj.a != null) return "A";
+            if (obj.b != null) return "B";
+            if (obj.c != null) return "C";
+            return null;
+          },
+        },
+        Named: {
+          __resolveType(obj) {
+            if (obj.a != null) return "A";
+            if (obj.b != null) return "B";
+            return null;
+          },
+        },
+      },
+    })),
+  ]);
+  expect(schema).toMatchSnapshot();
+  const { data, errors } = await graphql(
+    schema,
+    `
+      query {
+        abc {
+          __typename
+          ... on A {
+            name
+            nameLanguage
+            a
+          }
+          ... on B {
+            name
+            nameLanguage
+            b
+          }
+          ... on C {
+            c
+          }
+        }
+        named {
+          __typename
+          name
+          nameLanguage
+          ... on A {
+            a
+          }
+          ... on B {
+            b
+          }
+        }
+      }
+    `
+  );
+  expect(errors).toBeFalsy();
+  expect(data).toMatchSnapshot();
+});
diff --git a/packages/graphile-utils/__tests__/__snapshots__/ExtendSchemaPlugin.test.js.snap b/packages/graphile-utils/__tests__/__snapshots__/ExtendSchemaPlugin.test.js.snap
@@ -393,3 +393,77 @@ Object {
   },
 }
 `;
+
+exports[`supports interfaces and unions 1`] = `
+"""The root query type which gives access points into the data universe."""
+type Query {
+  """
+  Exposes the root query type nested one level down. This is helpful for Relay 1
+  which can only query top level fields if they are in a particular form.
+  """
+  query: Query!
+  abc: [ABC!]
+  named: [Named!]
+}
+
+union ABC = A | B | C
+
+type A implements Named {
+  name: String!
+  a: Int!
+  nameLanguage: String
+}
+
+interface Named {
+  name: String!
+  nameLanguage: String
+}
+
+type B implements Named {
+  name(suffix: String): String!
+  b: Int!
+  nameLanguage: String
+}
+
+type C {
+  c: Int!
+}
+
+`;
+
+exports[`supports interfaces and unions 2`] = `
+Object {
+  "abc": Array [
+    Object {
+      "__typename": "A",
+      "a": 1,
+      "name": "A-one",
+      "nameLanguage": "en",
+    },
+    Object {
+      "__typename": "B",
+      "b": 2,
+      "name": "B-two",
+      "nameLanguage": "en",
+    },
+    Object {
+      "__typename": "C",
+      "c": 3,
+    },
+  ],
+  "named": Array [
+    Object {
+      "__typename": "A",
+      "a": 1,
+      "name": "A-one",
+      "nameLanguage": "en",
+    },
+    Object {
+      "__typename": "B",
+      "b": 2,
+      "name": "B-two",
+      "nameLanguage": "en",
+    },
+  ],
+}
+`;
diff --git a/packages/graphile-utils/src/makeExtendSchemaPlugin.ts b/packages/graphile-utils/src/makeExtendSchemaPlugin.ts
