Object Type mocks

packages/plugin-mocks/src/global-types.ts

@@ -1,5 +1,5 @@
-import { SchemaTypes } from '@pothos/core';
-import { ResolverMap } from './types';
+import { ObjectParam, Resolver, SchemaTypes, ShapeFromTypeParam } from '@pothos/core';
+import { Mock, ResolverMap } from './types';
 import { MocksPlugin } from '.';
 
 declare global {
@@ -10,6 +10,19 @@ declare global {
 
     export interface BuildSchemaOptions<Types extends SchemaTypes> {
       mocks?: ResolverMap<Types>;
+      typeMocks?: Mock<Types>[];
+    }
+
+    export interface SchemaBuilder<Types extends SchemaTypes> {
+      createObjectMock: <
+        Shape extends NameOrRef extends ObjectParam<Types>
+          ? ShapeFromTypeParam<Types, NameOrRef, false>
+          : object,
+        NameOrRef extends ObjectParam<Types> | string,
+      >(
+        nameOrRef: NameOrRef,
+        resolver: Resolver<unknown, unknown, Types['Context'], Partial<Shape>>,
+      ) => Mock<Types>;
     }
   }
 }

packages/plugin-mocks/src/index.ts

@@ -1,7 +1,14 @@
 import './global-types';
+import './schema-builder';
 import { GraphQLFieldResolver } from 'graphql';
-import SchemaBuilder, { BasePlugin, PothosOutputFieldConfig, SchemaTypes } from '@pothos/core';
-import { ResolverMap } from './types';
+import SchemaBuilder, {
+  BasePlugin,
+  PothosOutputFieldConfig,
+  PothosOutputFieldType,
+  Resolver,
+  SchemaTypes,
+} from '@pothos/core';
+import { Mock, ResolverMap } from './types';
 
 const pluginName = 'mocks' as const;
 
@@ -11,13 +18,14 @@ export class MocksPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
     resolver: GraphQLFieldResolver<unknown, Types['Context'], object>,
     fieldConfig: PothosOutputFieldConfig<Types>,
   ): GraphQLFieldResolver<unknown, Types['Context'], object> {
-    const { mocks } = this.options;
+    const { mocks, typeMocks = [] } = this.options;
+    const { parentType: typeName, name: fieldName, type: outputType } = fieldConfig;
 
     if (!mocks) {
       return resolver;
     }
 
-    const resolveMock = this.resolveMock(fieldConfig.parentType, fieldConfig.name, mocks);
+    const resolveMock = this.resolveMock(typeName, fieldName, outputType, mocks, typeMocks);
 
     return resolveMock ?? resolver;
   }
@@ -37,18 +45,48 @@ export class MocksPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
     return subscribeMock ?? subscribe;
   }
 
-  resolveMock(typename: string, fieldName: string, mocks: ResolverMap<Types>) {
-    const fieldMock = mocks[typename]?.[fieldName] || null;
+  resolveMock(
+    typeName: string,
+    fieldName: string,
+    outputType: PothosOutputFieldType<Types>,
+    mocks: ResolverMap<Types>,
+    typeMocks: Mock<Types>[],
+  ): Resolver<unknown, {}, Types['Context'], unknown> | null {
+    const fieldMock = mocks[typeName]?.[fieldName] || null;
+
+    if (fieldMock) {
+      if (typeof fieldMock === 'function') {
+        return fieldMock;
+      }
+
+      return fieldMock.resolve ?? null;
+    }
 
-    if (!fieldMock) {
-      return null;
+    if (outputType.kind === 'Object') {
+      const outputName = (outputType.ref as { name: string }).name;
+      const mock = typeMocks.find((v) => v.name === outputName);
+
+      return mock?.resolver ?? null;
     }
 
-    if (typeof fieldMock === 'function') {
-      return fieldMock;
+    if (outputType.kind === 'Interface') {
+      const outputName = (outputType.ref as { name: string }).name;
+      const implementers = this.builder.configStore
+        .getImplementers(outputName)
+        .map((implementer) => implementer.name);
+      const mock = typeMocks.find((v) => implementers.includes(v.name));
+
+      return mock?.resolver ?? null;
+    }
+
+    if (outputType.kind === 'List') {
+      const result = this.resolveMock(typeName, fieldName, outputType.type, mocks, typeMocks);
+      if (result) {
+        return (...args) => [result(...args)];
+      }
     }
 
-    return fieldMock.resolve || null;
+    return null;
   }
 
   subscribeMock(typename: string, fieldName: string, mocks: ResolverMap<Types>) {

packages/plugin-mocks/src/schema-builder.ts

@@ -0,0 +1,12 @@
+import SchemaBuilder, { SchemaTypes } from '@pothos/core';
+
+const schemaBuilderProto = SchemaBuilder.prototype as PothosSchemaTypes.SchemaBuilder<SchemaTypes>;
+
+schemaBuilderProto.createObjectMock = function createMock(nameOrRef, resolver) {
+  const name = typeof nameOrRef === 'string' ? nameOrRef : (nameOrRef as { name: string }).name;
+
+  return {
+    name,
+    resolver: resolver as never,
+  };
+};

packages/plugin-mocks/src/types.ts

@@ -10,3 +10,8 @@ export type Resolvers<Types extends SchemaTypes, Parent> = Record<
 >;
 
 export type ResolverMap<Types extends SchemaTypes> = Record<string, Resolvers<Types, unknown>>;
+
+export interface Mock<Types extends SchemaTypes> {
+  name: string;
+  resolver: Resolver<unknown, unknown, Types['Context'], unknown>;
+}

packages/plugin-mocks/tests/__snapshots__/index.test.ts.snap

@@ -9,3 +9,28 @@ Object {
   },
 }
 `;
+
+exports[`mocked type mocks queries lists 1`] = `
+Object {
+  "data": Object {
+    "r2d2": Object {
+      "friends": Array [
+        Object {
+          "name": "C-3PO",
+        },
+      ],
+      "name": "C-3PO",
+    },
+  },
+}
+`;
+
+exports[`mocked type mocks queries stuff 1`] = `
+Object {
+  "data": Object {
+    "r2d2": Object {
+      "name": "C-3PO",
+    },
+  },
+}
+`;

packages/plugin-mocks/tests/index.test.ts

@@ -29,4 +29,63 @@ describe('mocked', () => {
 
     expect(result).toMatchSnapshot();
   });
+
+  describe('type mocks', () => {
+    it('queries stuff', async () => {
+      const DroidMock = builder.createObjectMock('Droid', () => ({
+        name: 'C-3PO',
+      }));
+      const mockedSchema = builder.toSchema({
+        mocks: {},
+        typeMocks: [DroidMock],
+      });
+
+      const query = gql`
+        query {
+          r2d2 {
+            name
+          }
+        }
+      `;
+
+      const result = await execute({
+        schema: mockedSchema,
+        document: query,
+        contextValue: {},
+      });
+
+      expect(result).toMatchSnapshot();
+    });
+
+    it('queries lists', async () => {
+      const DroidMock = builder.createObjectMock('Droid', () => ({
+        type: 'Droid' as const,
+        name: 'C-3PO',
+        friends: ['1002', '1003'],
+      }));
+      const mockedSchema = builder.toSchema({
+        mocks: {},
+        typeMocks: [DroidMock],
+      });
+
+      const query = gql`
+        query {
+          r2d2 {
+            name
+            friends {
+              name
+            }
+          }
+        }
+      `;
+
+      const result = await execute({
+        schema: mockedSchema,
+        document: query,
+        contextValue: {},
+      });
+
+      expect(result).toMatchSnapshot();
+    });
+  });
 });