feat: added new function composeMongoose which generates TypeComposer without resolvers. Now Resolvers can be generated on-demand in such way PostTC.generateResolver.findMany() (before was PostTC.getResolver('findMany')).

related #263

Author: nodkz

src/__tests__/github_issues/263-test.ts

@@ -0,0 +1,108 @@
+import { schemaComposer, graphql } from 'graphql-compose';
+import { composeMongoose } from '../../index';
+import { mongoose } from '../../__mocks__/mongooseCommon';
+import { Document } from 'mongoose';
+
+const UserSchema = new mongoose.Schema({
+  name: { type: String, required: true },
+});
+
+interface IUser extends Document {
+  name: string;
+}
+
+const PostSchema = new mongoose.Schema({
+  title: { type: String, required: true },
+  authorId: { type: mongoose.Types.ObjectId },
+  reviewerIds: { type: [mongoose.Types.ObjectId] },
+});
+
+interface IPost extends Document {
+  title: string;
+  authorId?: mongoose.Types.ObjectId;
+  reviewerIds?: [mongoose.Types.ObjectId];
+}
+
+const UserModel = mongoose.model<IUser>('User', UserSchema);
+const PostModel = mongoose.model<IPost>('Post', PostSchema);
+
+const UserTC = composeMongoose(UserModel);
+const PostTC = composeMongoose(PostModel);
+
+PostTC.addRelation('author', {
+  resolver: UserTC.generateResolver.dataLoaderLean(),
+  prepareArgs: {
+    _id: (s) => s.authorId,
+  },
+  projection: { authorId: true },
+});
+
+PostTC.addRelation('reviewers', {
+  resolver: UserTC.generateResolver.dataLoaderManyLean(),
+  prepareArgs: {
+    _ids: (s) => s.reviewerIds,
+  },
+  projection: { reviewerIds: true },
+});
+
+schemaComposer.Query.addFields({
+  posts: PostTC.generateResolver.findMany(),
+});
+const schema = schemaComposer.buildSchema();
+
+// console.log(schemaComposer.toSDL());
+
+beforeAll(async () => {
+  await UserModel.base.createConnection();
+  const User1 = await UserModel.create({ name: 'User1' });
+  const User2 = await UserModel.create({ name: 'User2' });
+  const User3 = await UserModel.create({ name: 'User3' });
+
+  await PostModel.create({ title: 'Post1', authorId: User1._id });
+  await PostModel.create({ title: 'Post2', authorId: User1._id, reviewerIds: [] });
+  await PostModel.create({ title: 'Post3', authorId: User1._id, reviewerIds: [User2._id] });
+  await PostModel.create({ title: 'Post4', authorId: User2._id, reviewerIds: [User1._id] });
+  await PostModel.create({ title: 'Post5', authorId: User2._id, reviewerIds: [User1._id] });
+  await PostModel.create({
+    title: 'Post6',
+    authorId: User3._id,
+    reviewerIds: [User1._id, User2._id],
+  });
+});
+afterAll(() => UserModel.base.disconnect());
+
+describe('issue #263 - new resolvers which works via DataLoader', () => {
+  it('check response', async () => {
+    // 👀 uncomment next line if you want to see real mongoose queries
+    // mongoose.set('debug', true);
+
+    expect(
+      await graphql.graphql({
+        schema,
+        source: `query {
+          posts {
+            title
+            author { name }
+            reviewers { name }
+          }
+        }`,
+        contextValue: {},
+      })
+    ).toEqual({
+      data: {
+        posts: [
+          { title: 'Post1', author: { name: 'User1' }, reviewers: [] },
+          { title: 'Post2', author: { name: 'User1' }, reviewers: [] },
+          { title: 'Post3', author: { name: 'User1' }, reviewers: [{ name: 'User2' }] },
+          { title: 'Post4', author: { name: 'User2' }, reviewers: [{ name: 'User1' }] },
+          { title: 'Post5', author: { name: 'User2' }, reviewers: [{ name: 'User1' }] },
+          {
+            title: 'Post6',
+            author: { name: 'User3' },
+            reviewers: [{ name: 'User1' }, { name: 'User2' }],
+          },
+        ],
+      },
+    });
+  });
+});

src/composeMongoose.ts

@@ -0,0 +1,85 @@
+import type { ObjectTypeComposer, SchemaComposer, Resolver } from 'graphql-compose';
+import { schemaComposer as globalSchemaComposer } from 'graphql-compose';
+import type { Model, Document } from 'mongoose';
+import { convertModelToGraphQL } from './fieldsConverter';
+import { allResolvers } from './resolvers';
+import MongoID from './types/MongoID';
+import { ArgsMap } from './resolvers/helpers';
+import {
+  prepareFields,
+  createInputType,
+  TransformRecordIdFn,
+  TypeConverterInputTypeOpts,
+} from './composeWithMongoose';
+
+export type ComposeMongooseOpts<TContext> = {
+  schemaComposer?: SchemaComposer<TContext>;
+  name?: string;
+  description?: string;
+  fields?: {
+    only?: string[];
+    // rename?: { [oldName: string]: string },
+    remove?: string[];
+  };
+  inputType?: TypeConverterInputTypeOpts;
+  /** You may customize `recordId` field in mutation payloads */
+  transformRecordId?: TransformRecordIdFn<TContext>;
+};
+
+export type GenerateResolverType<TDoc extends Document, TContext = any> = {
+  // get all available resolver generators, then leave only 3rd arg – opts
+  // because first two args will be attached via bind() method at runtime:
+  //   count = count.bind(undefined, model, tc);
+  [resolver in keyof typeof allResolvers]: <TSource = any>(
+    opts?: Parameters<typeof allResolvers[resolver]>[2]
+  ) => Resolver<TSource, TContext, ArgsMap, TDoc>;
+};
+
+export function composeMongoose<TDoc extends Document, TContext = any>(
+  model: Model<TDoc>,
+  opts: ComposeMongooseOpts<TContext> = {}
+): ObjectTypeComposer<TDoc, TContext> & {
+  generateResolver: GenerateResolverType<TDoc, TContext>;
+} {
+  const m: Model<any> = model;
+  const name: string = (opts && opts.name) || m.modelName;
+
+  const sc = opts.schemaComposer || globalSchemaComposer;
+  sc.add(MongoID);
+
+  if (sc.has(name)) {
+    throw new Error(
+      `You try to generate GraphQL Type with name ${name} from mongoose model but this type already exists in SchemaComposer. Please choose another type name "composeWithMongoose(model, { name: 'NewTypeName' })", or reuse existed type "schemaComposer.getOTC('TypeName')", or remove type from SchemaComposer before calling composeWithMongoose method "schemaComposer.delete('TypeName')".`
+    );
+  }
+  if (sc.has(m.schema)) {
+    // looks like you want to generate new TypeComposer from model
+    // so remove cached model (which is used for cross-reference types)
+    sc.delete(m.schema);
+  }
+
+  const tc = convertModelToGraphQL(m, name, sc);
+
+  if (opts.description) {
+    tc.setDescription(opts.description);
+  }
+
+  if (opts.fields) {
+    prepareFields(tc, opts.fields);
+  }
+
+  if (opts.inputType) {
+    // generate input type only it was customized
+    createInputType(tc, opts.inputType);
+  }
+
+  tc.makeFieldNonNull('_id');
+
+  const generateResolver = {} as any;
+  Object.keys(allResolvers).forEach((name) => {
+    generateResolver[name] = (allResolvers as any)[name].bind(undefined, model, tc);
+  });
+  (tc as any).generateResolver = generateResolver;
+
+  return tc as any;
+}

src/composeWithMongoose.ts

@@ -4,7 +4,7 @@ import type { ObjectTypeComposer, InputTypeComposer, SchemaComposer } from 'grap
 import { schemaComposer as globalSchemaComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
 import { convertModelToGraphQL } from './fieldsConverter';
-import * as resolvers from './resolvers';
+import { allResolvers, AllResolversOpts } from './resolvers';
 import MongoID from './types/MongoID';
 import { GraphQLResolveInfo } from 'graphql';
 
@@ -18,7 +18,7 @@ export type ComposeWithMongooseOpts<TContext> = {
     remove?: string[];
   };
   inputType?: TypeConverterInputTypeOpts;
-  resolvers?: false | resolvers.AllResolversOpts;
+  resolvers?: false | AllResolversOpts;
   /** You may customize document id */
   transformRecordId?: TransformRecordIdFn<TContext>;
 };
@@ -145,11 +145,11 @@ export function createInputType(
 export function createResolvers(
   model: Model<any>,
   tc: ObjectTypeComposer<any, any>,
-  opts: resolvers.AllResolversOpts
+  opts: AllResolversOpts
 ): void {
-  resolvers.availableResolverNames.forEach((resolverName) => {
-    if (!{}.hasOwnProperty.call(opts, resolverName) || opts[resolverName] !== false) {
-      const createResolverFn = resolvers[resolverName] as any;
+  (Object.keys(allResolvers) as any).forEach((resolverName: keyof typeof allResolvers) => {
+    if (!opts.hasOwnProperty(resolverName) || opts[resolverName] !== false) {
+      const createResolverFn = allResolvers[resolverName] as any;
       if (typeof createResolverFn === 'function') {
         const resolver = createResolverFn(model, tc, opts[resolverName] || {});
         if (resolver) {

src/discriminators/prepareBaseResolvers.ts

@@ -1,5 +1,5 @@
 import type { Resolver } from 'graphql-compose';
-import { availableResolverNames } from '../resolvers';
+import { allResolvers } from '../resolvers';
 import { DiscriminatorTypeComposer } from './DiscriminatorTypeComposer';
 
 // change type on DKey generated by composeWithMongoose
@@ -28,7 +28,7 @@ function setDKeyEnumOnITCArgs(resolver: Resolver, baseTC: DiscriminatorTypeCompo
 // Also sets up DKey enum as type for DKey field on composers with filter and/or record args
 // composeWithMongoose composers
 export function prepareBaseResolvers(baseTC: DiscriminatorTypeComposer<any, any>): void {
-  availableResolverNames.forEach((resolverName) => {
+  Object.keys(allResolvers).forEach((resolverName) => {
     if (baseTC.hasResolver(resolverName)) {
       const resolver = baseTC.getResolver(resolverName);
 

src/discriminators/prepareChildResolvers.ts

@@ -3,7 +3,7 @@ import {
   ComposeWithMongooseDiscriminatorsOpts,
   DiscriminatorTypeComposer,
 } from './DiscriminatorTypeComposer';
-import { availableResolverNames } from '../resolvers';
+import { allResolvers } from '../resolvers';
 
 // set the DKey as a query on filter, also project it
 // Also look at it like setting for filters, makes sure to limit
@@ -136,7 +136,7 @@ export function prepareChildResolvers<TSource, TContext>(
   childTC: ObjectTypeComposer<TSource, TContext>,
   opts: ComposeWithMongooseDiscriminatorsOpts<TContext>
 ): void {
-  availableResolverNames.forEach((resolverName) => {
+  Object.keys(allResolvers).forEach((resolverName) => {
     if (childTC.hasResolver(resolverName)) {
       const resolver = childTC.getResolver(resolverName);
 

src/fieldsConverter.ts

@@ -146,6 +146,8 @@ export function convertModelToGraphQL<TDoc extends Document, TContext>(
     return sc.getOTC(model.schema);
   }
 
+  // add type to registry before fields creation
+  // it helps to avoid circuit dependencies, eg. `User { friends: [User] }`
   const typeComposer = sc.getOrCreateOTC(typeName);
   sc.set(model.schema, typeComposer);
   sc.set(typeName, typeComposer);
@@ -167,7 +169,7 @@ export function convertModelToGraphQL<TDoc extends Document, TContext>(
 
     if (
       mongooseField.isRequired &&
-      // conditional required field in mongoose cannot be NonNulable in GraphQL
+      // conditional required field in mongoose cannot be NonNullable in GraphQL
       typeof mongooseField?.originalRequiredValue !== 'function'
     ) {
       requiredFields.push(fieldName);

src/index.ts

@@ -5,6 +5,7 @@ import GraphQLBSONDecimal from './types/BSONDecimal';
 export default composeWithMongoose;
 
 export * from './composeWithMongoose';
+export * from './composeMongoose';
 export * from './composeWithMongooseDiscriminators';
 export * from './fieldsConverter';
 export * from './resolvers';

src/resolvers/__tests__/connection-test.ts

@@ -1,9 +1,9 @@
 import { Resolver, schemaComposer, ObjectTypeComposer } from 'graphql-compose';
 import { Query } from 'mongoose';
 import { UserModel, IUser } from '../../__mocks__/userModel';
-import connection, { prepareCursorQuery } from '../connection';
-import findMany from '../findMany';
-import count from '../count';
+import { connection, prepareCursorQuery } from '../connection';
+import { findMany } from '../findMany';
+import { count } from '../count';
 import { convertModelToGraphQL } from '../../fieldsConverter';
 import { ExtendedResolveParams } from '..';
 

src/resolvers/__tests__/count-test.ts

@@ -1,7 +1,7 @@
 import { Resolver, schemaComposer, ObjectTypeComposer } from 'graphql-compose';
 import { GraphQLInt } from 'graphql-compose/lib/graphql';
 import { UserModel } from '../../__mocks__/userModel';
-import count from '../count';
+import { count } from '../count';
 import { convertModelToGraphQL } from '../../fieldsConverter';
 import { ExtendedResolveParams } from '..';
 

src/resolvers/__tests__/createMany-test.ts

@@ -5,7 +5,7 @@ import { GraphQLInt, GraphQLList, GraphQLNonNull } from 'graphql-compose/lib/gra
 import { mongoose } from '../../__mocks__/mongooseCommon';
 import { UserModel, IUser } from '../../__mocks__/userModel';
 import { convertModelToGraphQL } from '../../fieldsConverter';
-import createMany from '../createMany';
+import { createMany } from '../createMany';
 import { ExtendedResolveParams } from '..';
 
 beforeAll(() => UserModel.base.createConnection());