feat: add support for IoC in resolvers defined as classes (#52)

Closes: #50

README.md

@@ -54,6 +54,94 @@ Route.group(() => {
 }).middleware('auth');
 ```
 
+### Schema
+
+The GraphQL schema should be defined in `.graphql` files (by default located in `app/Schemas`).
+The schema folders are scanned recursively.
+
+```graphql
+type Query {
+  hello: String!
+  rectangle: Rectangle!
+}
+
+type Rectangle {
+  width: Int!
+  height: Int!
+  area: Int!
+}
+```
+
+### Resolvers
+
+Resolvers should be exported from `.ts` files (by default located in `app/Resolvers`).
+Only the first level of resolver folders is scanned, so you can use sub-folders put additional code.
+
+All resolvers are merged into a single object, so you can define them in multiple files.
+
+There are two supported ways of defining resolvers:
+
+#### Exporting classes
+
+Multiple classes can be exported from a single file.
+The name of the exported binding will be used as the name of the GraphQL type.
+
+```ts
+export class Query {
+  hello() {
+    return 'world';
+  }
+
+  rectangle() {
+    return { width: 10, height: 20 };
+  }
+}
+
+export class Rectangle {
+  area(rectangle) {
+    return rectangle.width * rectangle.height;
+  }
+}
+```
+
+It is also possible to add the suffix `Resolvers` to the exported name to avoid potential conflicts:
+
+```ts
+interface Rectangle {
+  width: number;
+  height: number;
+}
+
+export class RectangleResolvers {
+  area(rectangle: Rectangle) {
+    return rectangle.width * rectangle.height;
+  }
+}
+```
+
+#### Exporting a single object
+
+When a single object is exported as default, it is assumed to be a map of resolvers.
+
+```ts
+interface Rectangle {
+  width: number;
+  height: number;
+}
+
+export default {
+  Query: {
+    hello: () => 'world',
+    rectangle() {
+      return { width: 10, height: 20 };
+    },
+  },
+  Rectangle: {
+    area: (rectangle: Rectangle) => rectangle.width * rectangle.height,
+  },
+};
+```
+
 ### Troubleshooting
 
 #### Error: Query root type must be provided

src/ApolloServer.ts

@@ -77,6 +77,7 @@ export default class ApolloServer<
       resolversPaths.map((resolverPath) =>
         path.join(application.appRoot, resolverPath),
       ),
+      this.$app.container,
     );
 
     if (application.inDev) {

src/__tests__/schema.test.ts

@@ -1,10 +1,13 @@
 import path from 'node:path';
 
+import { Ioc } from '@adonisjs/fold';
 import { FakeLogger } from '@adonisjs/logger';
 import { Kind } from 'graphql';
 
 import { getTypeDefsAndResolvers, printWarnings } from '../schema';
 
+const testIoC = new Ioc();
+
 describe('getTypeDefsAndResolvers', () => {
   const fixture = path.join(
     __dirname,
@@ -13,14 +16,15 @@ describe('getTypeDefsAndResolvers', () => {
   const result = getTypeDefsAndResolvers(
     [path.join(fixture, 'schemas')],
     [path.join(fixture, 'resolvers')],
+    testIoC,
   );
   it('should merge schemas', () => {
     // Query, Mutation
     expect(
       result.typeDefs.definitions.filter(
         (def) => def.kind === Kind.OBJECT_TYPE_DEFINITION,
       ),
-    ).toHaveLength(2);
+    ).toHaveLength(3);
 
     // URL, Bad, OtherBad
     expect(
@@ -34,6 +38,7 @@ describe('getTypeDefsAndResolvers', () => {
     expect(Object.keys(result.resolvers)).toStrictEqual([
       'Query',
       'Mutation',
+      'D',
       'URL',
     ]);
   });

src/loadResolvers.ts

@@ -0,0 +1,68 @@
+import assert from 'node:assert';
+
+import { loadFilesSync } from '@graphql-tools/load-files';
+import { mergeResolvers } from '@graphql-tools/merge';
+
+import { ContainerBindings, IocContract } from '@ioc:Adonis/Core/Application';
+
+type UnknownConstructor = new (...args: unknown[]) => unknown;
+
+const antiClashSuffix = 'Resolvers';
+
+export function loadResolvers(
+  resolversPaths: string[],
+  container: IocContract<ContainerBindings>,
+) {
+  const resolverModules = resolversPaths.flatMap((resolversPath) =>
+    loadFilesSync(resolversPath, { recursive: false }),
+  );
+  const resolversPartials = resolverModules.map((resolverModule) =>
+    makeResolversPartial(resolverModule, container),
+  );
+
+  return mergeResolvers(resolversPartials);
+}
+
+function makeResolversPartial(
+  resolverModule: Record<string, unknown>,
+  container: IocContract<ContainerBindings>,
+) {
+  return Object.fromEntries(
+    Object.entries(resolverModule)
+      .filter(
+        ([, value]) =>
+          (typeof value === 'object' && value !== null) ||
+          typeof value === 'function',
+      )
+      .map(([key, value]) => {
+        if (key.endsWith(antiClashSuffix) && key !== antiClashSuffix) {
+          key = key.slice(0, -antiClashSuffix.length);
+        }
+        if (typeof value === 'object' && value !== null) {
+          return [key, value];
+        } else {
+          assert(typeof value === 'function');
+          return [
+            key,
+            mapResolverClass(value as UnknownConstructor, container),
+          ];
+        }
+      }),
+  );
+}
+
+function mapResolverClass(
+  value: UnknownConstructor,
+  container: IocContract<ContainerBindings>,
+) {
+  const instance = container.make(value);
+  const prototype = Object.getPrototypeOf(instance);
+  return Object.fromEntries(
+    Object.entries(Object.getOwnPropertyDescriptors(prototype))
+      .filter(
+        ([name, desc]) =>
+          name !== 'constructor' && typeof desc.value === 'function',
+      )
+      .map(([name, desc]) => [name, desc.value.bind(instance)]),
+  );
+}

src/schema.ts

@@ -1,9 +1,11 @@
 import { loadFilesSync } from '@graphql-tools/load-files';
-import { mergeResolvers, mergeTypeDefs } from '@graphql-tools/merge';
+import { mergeTypeDefs } from '@graphql-tools/merge';
 import { Kind } from 'graphql';
 
+import { ContainerBindings, IocContract } from '@ioc:Adonis/Core/Application';
 import { LoggerContract } from '@ioc:Adonis/Core/Logger';
 
+import { loadResolvers } from './loadResolvers';
 import { scalarResolvers } from './scalarResolvers';
 
 interface SchemaWarnings {
@@ -15,17 +17,13 @@ interface SchemaWarnings {
 export function getTypeDefsAndResolvers(
   schemasPaths: string[],
   resolversPaths: string[],
+  container: IocContract<ContainerBindings>,
 ) {
   const typeDefs = mergeTypeDefs(
     schemasPaths.flatMap((schemasPath) => loadFilesSync(schemasPath)),
   );
-  const resolvers = {
-    ...mergeResolvers(
-      resolversPaths.flatMap((resolversPath) =>
-        loadFilesSync(resolversPath, { recursive: false }),
-      ),
-    ),
-  };
+
+  const resolvers = loadResolvers(resolversPaths, container);
 
   const warnings: SchemaWarnings = {
     missingQuery: [],
@@ -48,23 +46,25 @@ export function getTypeDefsAndResolvers(
     } else if (definition.kind === Kind.OBJECT_TYPE_DEFINITION) {
       const objectName = definition.name.value;
 
-      if (objectName === 'Query' && definition.fields) {
+      if (objectName === 'Query' && definition.fields && resolvers.Query) {
         // Warn about missing Query resolvers.
-        const queryResolvers = resolvers.Query || {};
         for (const queryField of definition.fields) {
           const queryName = queryField.name.value;
           // @ts-expect-error Using index signature for validation.
-          if (!queryResolvers[queryName]) {
+          if (!resolvers.Query[queryName]) {
             warnings.missingQuery.push(queryName);
           }
         }
-      } else if (objectName === 'Mutation' && definition.fields) {
+      } else if (
+        objectName === 'Mutation' &&
+        definition.fields &&
+        resolvers.Mutation
+      ) {
         // Warn about missing Mutation resolvers.
-        const mutationResolvers = resolvers.Mutation || {};
         for (const mutationField of definition.fields) {
           const mutationName = mutationField.name.value;
           // @ts-expect-error Using index signature for validation.
-          if (!mutationResolvers[mutationName]) {
+          if (!resolvers.Mutation[mutationName]) {
             warnings.missingMutation.push(mutationName);
           }
         }

test-utils/fixtures/schema/test1/resolvers/D.js

@@ -0,0 +1,13 @@
+'use strict';
+
+exports.Query = class Query {
+  queryD() {
+    return 'test';
+  }
+};
+
+exports.DResolvers = class D {
+  value() {
+    return 'test';
+  }
+};

test-utils/fixtures/schema/test1/schemas/Schema3.graphql

@@ -0,0 +1,7 @@
+type Query {
+  queryD: String
+}
+
+type D {
+  value: String!
+}