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

Author: vlad-x

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

@@ -92,6 +92,18 @@ export function createResolvers(
                 resolvers[typeName][fieldName].resolve = resolver;
               }
 
+              if (isDefined((obj[fieldName] as any).extensions)) {
+                // some extensions allow to omit the resolve function, e.g. grafast
+                const defaultResolver = (val: any) => val;
+                const resolver = wrapResolver({
+                  config,
+                  resolver: (obj[fieldName] as any).resolve || defaultResolver,
+                  middlewareMap,
+                  path,
+                });
+                resolvers[typeName][fieldName].resolve = resolver;
+              }
+
               // { subscribe }
               if (isDefined((obj[fieldName] as any).subscribe)) {
                 const resolver = wrapResolver({
@@ -286,6 +298,21 @@ function addObject({
           container[typeName][fieldName].resolve = resolver.resolve;
         }
 
+        // extensions
+        if (isDefined(resolver.extensions)) {
+          if (container[typeName][fieldName].extensions) {
+            throw new ResolverDuplicatedError(
+              `Duplicated resolver of "${typeName}.${fieldName}" (extensions method)`,
+              useLocation({ dirname: config.dirname, id: config.id })
+            );
+          }
+
+          (resolver.extensions as any)[resolverMetadataProp] = {
+            moduleId: config.id,
+          } as ResolverMetadata;
+          container[typeName][fieldName].extensions = resolver.extensions;
+        }
+
         // subscribe
         if (isDefined(resolver.subscribe)) {
           if (container[typeName][fieldName].subscribe) {
@@ -501,10 +528,15 @@ function isResolveFn(value: any): value is ResolveFn {
 interface ResolveOptions {
   resolve?: ResolveFn;
   subscribe?: ResolveFn;
+  extensions?: Record<string, 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 { resolve } from 'path';
 
 test('fail when modules have non-unique ids', async () => {
   const modFoo = createModule({
@@ -396,3 +397,34 @@ test('fail when modules have non-DocumentNode typeDefs', async () => {
     });
   }).toThrow(NonDocumentNodeError);
 });
+
+test('should allow resolver extensions', async () => {
+  const m1 = createModule({
+    id: 'test',
+    typeDefs: gql`
+      type Query {
+        dummy: String!
+      }
+    `,
+    resolvers: {
+      Query: {
+        dummy: {
+          resolve: () => '1',
+          extensions: {
+            test: 'test',
+          },
+        },
+      },
+    },
+  });
+
+  const app = createApplication({
+    modules: [m1],
+  });
+
+  const schema = app.schema;
+  expect(
+    Object.keys(schema.getQueryType()?.getFields().dummy.extensions || {})
+      .length
+  ).toBe(1);
+});