Enables support for resolver extensions for compatibility with grafast, complexity, etc. (#2618)

* Enables support for resolver extensions for compatibility with grafast, complexity, etc.

* Added an example on using resolver extensions to docs and added a changeset

* Extension support misc. fixes from code review

* Extensions should not cause a resolver to come into existence

* Don't create resolvers unless necessary

---------

Co-authored-by: Benjie Gillam <[email protected]>

Author: vlad-x

.changeset/nice-eels-press.md

@@ -0,0 +1,6 @@
+---
+'graphql-modules': minor
+'website': patch
+---
+
+Enabled support for resolver extensions for compatibility with such libraries as grafast or graphql-query-complexity

packages/graphql-modules/src/module/resolvers.ts

@@ -5,6 +5,7 @@ import {
   defaultFieldResolver,
   FieldNode,
   GraphQLResolveInfo,
+  GraphQLFieldExtensions,
 } from 'graphql';
 import { Resolvers, ModuleConfig } from './types';
 import { ModuleMetadata } from './metadata';
@@ -102,6 +103,13 @@ export function createResolvers(
                 });
                 resolvers[typeName][fieldName].subscribe = resolver;
               }
+
+              if (isDefined((obj[fieldName] as any).extensions)) {
+                // Do NOT add a resolve if one is not specified, it will cause
+                // change in behavior in systems like `grafast`
+                resolvers[typeName][fieldName].extensions =
+                  obj[fieldName].extensions;
+              }
             }
           }
         }
@@ -298,6 +306,19 @@ function addObject({
           writeResolverMetadata(resolver.subscribe, config);
           container[typeName][fieldName].subscribe = resolver.subscribe;
         }
+
+        // extensions
+        if (isDefined(resolver.extensions)) {
+          if (container[typeName][fieldName].extensions) {
+            throw new ResolverDuplicatedError(
+              `Duplicated resolver of "${typeName}.${fieldName}" (extensions object)`,
+              useLocation({ dirname: config.dirname, id: config.id })
+            );
+          }
+
+          writeResolverMetadata(resolver.extensions, config);
+          container[typeName][fieldName].extensions = resolver.extensions;
+        }
       }
     }
   }
@@ -399,7 +420,10 @@ function ensureImplements(metadata: ModuleMetadata) {
   };
 }
 
-function writeResolverMetadata(resolver: Function, config: ModuleConfig): void {
+function writeResolverMetadata(
+  resolver: Function | GraphQLFieldExtensions<any, any, any>,
+  config: ModuleConfig
+): void {
   if (!resolver) {
     return;
   }
@@ -409,7 +433,9 @@ function writeResolverMetadata(resolver: Function, config: ModuleConfig): void {
   } as ResolverMetadata;
 }
 
-export function readResolverMetadata(resolver: ResolveFn): ResolverMetadata {
+export function readResolverMetadata(
+  resolver: ResolveFn | GraphQLFieldExtensions<any, any, any>
+): ResolverMetadata {
   return (resolver as any)[resolverMetadataProp];
 }
 
@@ -501,10 +527,15 @@ function isResolveFn(value: any): value is ResolveFn {
 interface ResolveOptions {
   resolve?: ResolveFn;
   subscribe?: ResolveFn;
+  extensions?: GraphQLFieldExtensions<any, any, any>;
 }
 
 function isResolveOptions(value: any): value is ResolveOptions {
-  return isDefined(value.resolve) || isDefined(value.subscribe);
+  return (
+    isDefined(value.resolve) ||
+    isDefined(value.subscribe) ||
+    isDefined(value.extensions)
+  );
 }
 
 function isScalarResolver(obj: any): obj is GraphQLScalarType {

packages/graphql-modules/tests/bootstrap.spec.ts

@@ -2,6 +2,7 @@ import 'reflect-metadata';
 import { makeExecutableSchema } from '@graphql-tools/schema';
 import { createApplication, createModule, testkit, gql } from '../src';
 import { NonDocumentNodeError } from '../src/shared/errors';
+import { defaultFieldResolver } from 'graphql';
 
 test('fail when modules have non-unique ids', async () => {
   const modFoo = createModule({
@@ -396,3 +397,63 @@ test('fail when modules have non-DocumentNode typeDefs', async () => {
     });
   }).toThrow(NonDocumentNodeError);
 });
+
+describe('extensions', () => {
+  const makeApp = () => {
+    const m1 = createModule({
+      id: 'test',
+      typeDefs: gql`
+        type Query {
+          dummy: String!
+          dummy2: String!
+        }
+      `,
+      resolvers: {
+        Query: {
+          dummy: {
+            resolve: () => '1',
+            extensions: {
+              test: 'test',
+            },
+          },
+          dummy2: {
+            extensions: {
+              test2: 'test2',
+            },
+          },
+        },
+      },
+    });
+    const app = createApplication({
+      modules: [m1],
+    });
+    return app;
+  };
+
+  it('populates extensions', async () => {
+    const app = makeApp();
+    const schema = app.schema;
+    const fields = schema.getQueryType()!.getFields();
+
+    expect(fields.dummy.extensions).toMatchObject({
+      test: 'test',
+    });
+    expect(fields.dummy2.extensions).toMatchObject({
+      test2: 'test2',
+    });
+  });
+
+  it('does not create a resolver if one was not specified', async () => {
+    const app = makeApp();
+    const schema = app.schema;
+    const fields = schema.getQueryType()!.getFields();
+    // Doesn't matter if it's the default resolver or unset, it simply must not
+    // be a new function; otherwise `grafast` will interpret it as an
+    // additional part of execution which will likely break the user's plan.
+    if (fields.dummy2.resolve) {
+      expect(fields.dummy2.resolve).toEqual(defaultFieldResolver);
+    } else {
+      expect(fields.dummy2.resolve).toBeFalsy();
+    }
+  });
+});

website/src/content/essentials/resolvers.mdx

@@ -60,10 +60,7 @@ npm i @graphql-tools/load-files
 Next, use it to load your files dynamically:
 
 ```ts
-import MyQueryType from './query.type.graphql'
 import { createModule } from 'graphql-modules'
-import { loadFilesSync } from '@graphql-tools/load-files'
-import { join } from 'path'
 
 export const myModule = createModule({
   id: 'my-module',
@@ -72,3 +69,40 @@ export const myModule = createModule({
   resolvers: loadFilesSync(join(__dirname, './resolvers/*.ts'))
 })
 ```
+
+## Resolver Extensions
+
+You can use resolver extensions to extend the functionality of your resolvers to make your modules work with such extensions as [Grafast Plan Resolver](https://grafast.org/grafast/plan-resolvers#specifying-a-field-plan-resolver) or [GraphQL Query Complexity](https://github.com/slicknode/graphql-query-complexity/blob/HEAD/src/estimators/fieldExtensions/README.md).
+
+To use resolver extensions, you can use the `extensions` property in your resolvers.
+
+```ts
+import { createModule, gql } from 'graphql-modules'
+import { constant } from "grafast";
+
+export const myModule = createModule({
+  id: 'my-module',
+  dirname: __dirname,
+  typeDefs: [
+    gql`
+      type Query {
+        meaningOfLife: Int!
+      }
+    `
+  ],
+  resolvers: {
+    Query: {
+      meaningOfLife: {
+        extensions: {
+          grafast: {
+            plan() {
+              return constant(42);
+            },
+          },
+        },
+      },
+    }
+  }
+})
+```
+