Merge pull request #3503 from JoshVee/joshvee-resolver-transformation

feat(graphql): add support for transforming the resolvers

Author: kamilmysliwiec

packages/graphql/lib/graphql.factory.ts

@@ -34,11 +34,15 @@ export class GraphQLFactory {
     options: T = { typeDefs: [] } as T,
   ): Promise<GraphQLSchema> {
     const resolvers = this.resolversExplorerService.explore();
-    const typesResolvers = extend(
+    const rawResolvers = extend(
       this.scalarsExplorerService.explore(),
       resolvers,
     );
 
+    const typesResolvers = options.transformResolvers
+      ? await options.transformResolvers(rawResolvers)
+      : rawResolvers;
+
     const transformSchema = async (schema: GraphQLSchema) =>
       options.transformSchema ? await options.transformSchema(schema) : schema;
 

packages/graphql/lib/interfaces/gql-module-options.interface.ts

@@ -109,6 +109,17 @@ export interface GqlModuleOptions<TDriver extends GraphQLDriver = any> {
     schema: GraphQLSchema,
   ) => GraphQLSchema | Promise<GraphQLSchema>;
 
+  /**
+   * Function to be applied to the discovered resolvers letting you perform compositions.
+   */
+  transformResolvers?: (
+    resolvers: IResolvers | Array<IResolvers>,
+  ) =>
+    | IResolvers
+    | Array<IResolvers>
+    | Promise<IResolvers>
+    | Promise<Array<IResolvers>>;
+
   /**
    * Apply `transformSchema` to the `autoSchemaFile`
    */

packages/graphql/tests/graphql.factory.spec.ts

@@ -0,0 +1,86 @@
+import { Test } from '@nestjs/testing';
+
+import { GraphQLAstExplorer, GraphQLFactory } from '../lib';
+import { GraphQLSchemaBuilder } from '../lib/graphql-schema.builder';
+import { ResolversExplorerService } from '../lib/services/resolvers-explorer.service';
+import { ScalarsExplorerService } from '../lib/services/scalars-explorer.service';
+import gql from 'graphql-tag';
+import { GraphQLSchema } from 'graphql';
+
+describe('GraphQLFactory', () => {
+  let graphqlFactory: GraphQLFactory;
+  let resolverExplorer: { explore: jest.Mock };
+  let scalarExplorer: { explore: jest.Mock };
+
+  beforeEach(async () => {
+    resolverExplorer = { explore: jest.fn() };
+    scalarExplorer = { explore: jest.fn() };
+    const module = await Test.createTestingModule({
+      providers: [
+        {
+          provide: ResolversExplorerService,
+          useValue: resolverExplorer,
+        },
+        {
+          provide: ScalarsExplorerService,
+          useValue: scalarExplorer,
+        },
+        {
+          provide: GraphQLAstExplorer,
+          useValue: jest.fn(),
+        },
+        {
+          provide: GraphQLSchemaBuilder,
+          useValue: jest.fn(),
+        },
+        GraphQLFactory,
+      ],
+    }).compile();
+
+    graphqlFactory = module.get(GraphQLFactory);
+  });
+
+  describe('generateSchema', () => {
+    it('should support transforming the resolvers', async () => {
+      const resolvers = [{ Query: { echo: jest.fn() } }];
+
+      resolverExplorer.explore.mockReturnValueOnce(resolvers);
+      scalarExplorer.explore.mockReturnValueOnce([]);
+
+      const transformResolvers = jest.fn((r) => r);
+
+      const schema = await graphqlFactory.generateSchema({
+        transformResolvers,
+        typeDefs: `
+          type Query {
+            echo(text: String!): String
+          }
+        `,
+      });
+
+      expect(transformResolvers).toHaveBeenCalledWith(resolvers);
+      expect(resolverExplorer.explore).toHaveBeenCalled();
+      expect(scalarExplorer.explore).toHaveBeenCalled();
+      expect(schema).toBeInstanceOf(GraphQLSchema);
+    });
+
+    it('should support undefined transformResolvers option', async () => {
+      const resolvers = [{ Query: { echo: jest.fn() } }];
+
+      resolverExplorer.explore.mockReturnValueOnce(resolvers);
+      scalarExplorer.explore.mockReturnValueOnce([]);
+
+      const schema = await graphqlFactory.generateSchema({
+        typeDefs: `
+          type Query {
+            echo(text: String!): String
+          }
+        `,
+      });
+
+      expect(resolverExplorer.explore).toHaveBeenCalled();
+      expect(scalarExplorer.explore).toHaveBeenCalled();
+      expect(schema).toBeInstanceOf(GraphQLSchema);
+    });
+  });
+});