fix(graphql): allow resolvers to be registered in provider wrappers

Author: Carl Evans

packages/apollo/tests/code-first/cats/cats.module.ts

@@ -0,0 +1,45 @@
+import { Module } from '@nestjs/common';
+import { CatsResolver } from './cats.resolver';
+
+@Module({})
+export class CatsModule {
+  static register(resolverRegistrationMethod: 'useClass'|'useFactory'|'useValue') {
+    switch (resolverRegistrationMethod) {
+      case 'useClass':
+        return {
+          module: CatsModule,
+          providers: [
+            {
+              provide: CatsResolver,
+              useClass: CatsResolver
+            },
+          ],
+        };
+
+      case 'useValue':
+        return {
+          module: CatsModule,
+          providers: [
+            {
+              provide: CatsResolver,
+              useValue: new CatsResolver(),
+            },
+          ],
+        };
+
+      case 'useFactory':
+      default:
+        return {
+          module: CatsModule,
+          providers: [
+            {
+              provide: CatsResolver,
+              useFactory() {
+                return new CatsResolver();
+              },
+            },
+          ],
+        };
+    }
+  }
+}

packages/apollo/tests/code-first/cats/cats.resolver.ts

@@ -0,0 +1,9 @@
+import { Query, Resolver } from '@nestjs/graphql';
+
+@Resolver()
+export class CatsResolver {
+  @Query(returns => String)
+  getAnimalName(): string {
+    return 'cat';
+  }
+}

packages/apollo/tests/e2e/resolver-registration-methods.spec.ts

@@ -0,0 +1,99 @@
+import { INestApplication } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import * as request from 'supertest';
+import { ApplicationModule } from '../code-first/app.module';
+import { CatsModule } from '../code-first/cats/cats.module';
+
+describe('GraphQL - Resolver registration methods', () => {
+    let app: INestApplication;
+  
+    describe('useClass', () => {
+        beforeEach(async () => {
+            const module = await Test.createTestingModule({
+                imports: [ApplicationModule, CatsModule.register('useClass')],
+            }).compile();
+      
+            app = module.createNestApplication();
+            await app.init();
+        });
+
+        it('should return the cats result', async () => {
+            return request(app.getHttpServer())
+                .post('/graphql')
+                .send({
+                    operationName: null,
+                    variables: {},
+                    query: 'query {\n  getAnimalName \n}\n',
+                })
+                .expect(200, {
+                    data: {
+                        getAnimalName: 'cat',
+                    }
+                });
+        });
+
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+  
+    describe('useValue', () => {
+        beforeEach(async () => {
+            const module = await Test.createTestingModule({
+                imports: [ApplicationModule, CatsModule.register('useValue')],
+            }).compile();
+  
+            app = module.createNestApplication();
+            await app.init();
+        });
+
+        it('should return the cats result', async () => {
+            return request(app.getHttpServer())
+                .post('/graphql')
+                .send({
+                    operationName: null,
+                    variables: {},
+                    query: 'query {\n  getAnimalName \n}\n',
+                })
+                .expect(200, {
+                    data: {
+                        getAnimalName: 'cat',
+                    }
+                });
+        });
+
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+  
+    describe('useFactory', () => {
+        beforeEach(async () => {
+            const module = await Test.createTestingModule({
+                imports: [ApplicationModule, CatsModule.register('useFactory')],
+            }).compile();
+  
+            app = module.createNestApplication();
+            await app.init();
+        });
+  
+        it('should return the cats result', async () => {
+            return request(app.getHttpServer())
+                .post('/graphql')
+                .send({
+                    operationName: null,
+                    variables: {},
+                    query: 'query {\n  getAnimalName \n}\n',
+                })
+                .expect(200, {
+                    data: {
+                        getAnimalName: 'cat',
+                    }
+                });
+        });
+
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+});

packages/graphql/lib/services/resolvers-explorer.service.ts

@@ -279,12 +279,21 @@ export class ResolversExplorerService extends BaseExplorerService {
     };
   }
 
+  mapCtors(wrapper: InstanceWrapper): Function[] {
+    const { instance } = wrapper;
+    if (!instance) {
+      return undefined;
+    }
+
+    return instance.constructor;
+  }
+
   getAllCtors(): Function[] {
     const modules = this.getModules(
       this.modulesContainer,
       this.gqlOptions.include || [],
     );
-    const resolvers = this.flatMap(modules, (instance) => instance.metatype);
+    const resolvers = this.flatMap(modules, this.mapCtors).filter(Boolean);
     return resolvers;
   }
 

packages/mercurius/tests/code-first/cats/cats.module.ts

@@ -0,0 +1,45 @@
+import { Module } from '@nestjs/common';
+import { CatsResolver } from './cats.resolver';
+
+@Module({})
+export class CatsModule {
+  static register(resolverRegistrationMethod: 'useClass'|'useFactory'|'useValue') {
+    switch (resolverRegistrationMethod) {
+      case 'useClass':
+        return {
+          module: CatsModule,
+          providers: [
+            {
+              provide: CatsResolver,
+              useClass: CatsResolver
+            },
+          ],
+        };
+
+      case 'useValue':
+        return {
+          module: CatsModule,
+          providers: [
+            {
+              provide: CatsResolver,
+              useValue: new CatsResolver(),
+            },
+          ],
+        };
+
+      case 'useFactory':
+      default:
+        return {
+          module: CatsModule,
+          providers: [
+            {
+              provide: CatsResolver,
+              useFactory() {
+                return new CatsResolver();
+              },
+            },
+          ],
+        };
+    }
+  }
+}

packages/mercurius/tests/code-first/cats/cats.resolver.ts

@@ -0,0 +1,9 @@
+import { Query, Resolver } from '@nestjs/graphql';
+
+@Resolver()
+export class CatsResolver {
+  @Query(returns => String)
+  getAnimalName(): string {
+    return 'cat';
+  }
+}

packages/mercurius/tests/e2e/resolver-registration-methods.spec.ts

@@ -0,0 +1,85 @@
+import { INestApplication } from '@nestjs/common';
+import { FastifyAdapter } from '@nestjs/platform-fastify';
+import { Test } from '@nestjs/testing';
+import mercurius from 'mercurius';
+import { ApplicationModule } from '../code-first/app.module';
+import { CatsModule } from '../code-first/cats/cats.module';
+
+describe('GraphQL - Resolver registration methods', () => {
+    let app: INestApplication;
+  
+    describe('useClass', () => {
+        beforeEach(async () => {
+            const module = await Test.createTestingModule({
+                imports: [ApplicationModule, CatsModule.register('useClass')],
+            }).compile();
+      
+            app = module.createNestApplication(new FastifyAdapter());
+            await app.init();
+            await app.getHttpAdapter().getInstance().ready();
+        });
+
+        it('should return the cats result', async () => {
+            const fastifyInstance = app.getHttpAdapter().getInstance();
+            const response = await fastifyInstance.graphql(
+                'query {\n  getAnimalName \n}\n',
+            );
+
+            expect(response.data).toEqual({ getAnimalName: 'cat' });
+        });
+
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+  
+    describe('useValue', () => {
+        beforeEach(async () => {
+            const module = await Test.createTestingModule({
+                imports: [ApplicationModule, CatsModule.register('useValue')],
+            }).compile();
+      
+            app = module.createNestApplication(new FastifyAdapter());
+            await app.init();
+            await app.getHttpAdapter().getInstance().ready();
+        });
+
+        it('should return the cats result', async () => {
+            const fastifyInstance = app.getHttpAdapter().getInstance();
+            const response = await fastifyInstance.graphql(
+                'query {\n  getAnimalName \n}\n',
+            );
+
+            expect(response.data).toEqual({ getAnimalName: 'cat' });
+        });
+
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+  
+    describe('useFactory', () => {
+        beforeEach(async () => {
+            const module = await Test.createTestingModule({
+                imports: [ApplicationModule, CatsModule.register('useFactory')],
+            }).compile();
+      
+            app = module.createNestApplication(new FastifyAdapter());
+            await app.init();
+            await app.getHttpAdapter().getInstance().ready();
+        });
+
+        it('should return the cats result', async () => {
+            const fastifyInstance = app.getHttpAdapter().getInstance();
+            const response = await fastifyInstance.graphql(
+                'query {\n  getAnimalName \n}\n',
+            );
+
+            expect(response.data).toEqual({ getAnimalName: 'cat' });
+        });
+
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+});