refactor: move resolvers options typedefs to theirs files

related #263

Author: nodkz

src/composeWithMongoose.ts

@@ -2,18 +2,11 @@
 
 import type { ObjectTypeComposer, InputTypeComposer, SchemaComposer } from 'graphql-compose';
 import { schemaComposer as globalSchemaComposer } from 'graphql-compose';
-import type { Model } from 'mongoose';
+import type { Model, Document } from 'mongoose';
 import { convertModelToGraphQL } from './fieldsConverter';
 import * as resolvers from './resolvers';
-import type {
-  FilterHelperArgsOpts,
-  LimitHelperArgsOpts,
-  SortHelperArgsOpts,
-  RecordHelperArgsOpts,
-} from './resolvers/helpers';
 import MongoID from './types/MongoID';
-import type { PaginationResolverOpts } from './resolvers/pagination';
-import type { ConnectionOpts } from './resolvers/connection';
+import { GraphQLResolveInfo } from 'graphql';
 
 export type ComposeWithMongooseOpts<TContext> = {
   schemaComposer?: SchemaComposer<TContext>;
@@ -25,9 +18,17 @@ export type ComposeWithMongooseOpts<TContext> = {
     remove?: string[];
   };
   inputType?: TypeConverterInputTypeOpts;
-  resolvers?: false | TypeConverterResolversOpts;
+  resolvers?: false | resolvers.AllResolversOpts;
+  /** You may customize document id */
+  transformRecordId?: TransformRecordIdFn<TContext>;
 };
 
+export type TransformRecordIdFn<TContext = any> = (
+  source: Document,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => any;
+
 export type TypeConverterInputTypeOpts = {
   name?: string;
   description?: string;
@@ -38,108 +39,6 @@ export type TypeConverterInputTypeOpts = {
   };
 };
 
-export type TypeConverterResolversOpts = {
-  findById?: false;
-  findByIds?:
-    | false
-    | {
-        limit?: LimitHelperArgsOpts | false;
-        sort?: SortHelperArgsOpts | false;
-      };
-  findOne?:
-    | false
-    | {
-        filter?: FilterHelperArgsOpts | false;
-        sort?: SortHelperArgsOpts | false;
-        skip?: false;
-      };
-  findMany?:
-    | false
-    | {
-        filter?: FilterHelperArgsOpts | false;
-        sort?: SortHelperArgsOpts | false;
-        limit?: LimitHelperArgsOpts | false;
-        skip?: false;
-      };
-  findByIdLean?: false;
-  findByIdsLean?:
-    | false
-    | {
-        limit?: LimitHelperArgsOpts | false;
-        sort?: SortHelperArgsOpts | false;
-      };
-  findOneLean?:
-    | false
-    | {
-        filter?: FilterHelperArgsOpts | false;
-        sort?: SortHelperArgsOpts | false;
-        skip?: false;
-      };
-  findManyLean?:
-    | false
-    | {
-        filter?: FilterHelperArgsOpts | false;
-        sort?: SortHelperArgsOpts | false;
-        limit?: LimitHelperArgsOpts | false;
-        skip?: false;
-      };
-  dataLoader?: false;
-  dataLoaderLean?: false;
-  dataLoaderMany?: false;
-  dataLoaderManyLean?: false;
-  updateById?:
-    | false
-    | {
-        record?: RecordHelperArgsOpts | false;
-      };
-  updateOne?:
-    | false
-    | {
-        record?: RecordHelperArgsOpts | false;
-        filter?: FilterHelperArgsOpts | false;
-        sort?: SortHelperArgsOpts | false;
-        skip?: false;
-      };
-  updateMany?:
-    | false
-    | {
-        record?: RecordHelperArgsOpts | false;
-        filter?: FilterHelperArgsOpts | false;
-        sort?: SortHelperArgsOpts | false;
-        limit?: LimitHelperArgsOpts | false;
-        skip?: false;
-      };
-  removeById?: false;
-  removeOne?:
-    | false
-    | {
-        filter?: FilterHelperArgsOpts | false;
-        sort?: SortHelperArgsOpts | false;
-      };
-  removeMany?:
-    | false
-    | {
-        filter?: FilterHelperArgsOpts | false;
-      };
-  createOne?:
-    | false
-    | {
-        record?: RecordHelperArgsOpts | false;
-      };
-  createMany?:
-    | false
-    | {
-        records?: RecordHelperArgsOpts | false;
-      };
-  count?:
-    | false
-    | {
-        filter?: FilterHelperArgsOpts | false;
-      };
-  connection?: ConnectionOpts<any> | false;
-  pagination?: PaginationResolverOpts | false;
-};
-
 export function composeWithMongoose<TSource = any, TContext = any>(
   model: Model<any>,
   opts: ComposeWithMongooseOpts<TContext> = {}
@@ -248,10 +147,9 @@ export function createInputType(
 export function createResolvers(
   model: Model<any>,
   tc: ObjectTypeComposer<any, any>,
-  opts: TypeConverterResolversOpts
+  opts: resolvers.AllResolversOpts
 ): void {
-  const names = resolvers.getAvailableNames();
-  names.forEach((resolverName) => {
+  resolvers.availableResolverNames.forEach((resolverName) => {
     if (!{}.hasOwnProperty.call(opts, resolverName) || opts[resolverName] !== false) {
       const createResolverFn = resolvers[resolverName] as any;
       if (typeof createResolverFn === 'function') {

src/discriminators/prepareBaseResolvers.ts

@@ -1,5 +1,5 @@
 import type { Resolver } from 'graphql-compose';
-import { EMCResolvers } from '../resolvers';
+import { availableResolverNames } from '../resolvers';
 import { DiscriminatorTypeComposer } from './DiscriminatorTypeComposer';
 
 // change type on DKey generated by composeWithMongoose
@@ -28,30 +28,30 @@ 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 {
-  for (const resolverName in EMCResolvers) {
-    if (EMCResolvers.hasOwnProperty(resolverName) && baseTC.hasResolver(resolverName)) {
+  availableResolverNames.forEach((resolverName) => {
+    if (baseTC.hasResolver(resolverName)) {
       const resolver = baseTC.getResolver(resolverName);
 
       switch (resolverName) {
-        case EMCResolvers.findMany:
-        case EMCResolvers.findByIds:
+        case 'findMany':
+        case 'findByIds':
           resolver.setType(baseTC.getDInterface().List);
           // @ts-expect-error
           resolver.projection[baseTC.getDKey()] = 1;
           break;
 
-        case EMCResolvers.findById:
-        case EMCResolvers.findOne:
+        case 'findById':
+        case 'findOne':
           resolver.setType(baseTC.getDInterface());
           // @ts-expect-error
           resolver.projection[baseTC.getDKey()] = 1;
           break;
 
-        case EMCResolvers.createOne:
-        case EMCResolvers.updateOne:
-        case EMCResolvers.updateById:
-        case EMCResolvers.removeOne:
-        case EMCResolvers.removeById:
+        case 'createOne':
+        case 'updateOne':
+        case 'updateById':
+        case 'removeOne':
+        case 'removeById':
           resolver.getOTC().extendField('record', {
             type: baseTC.getDInterface(),
             projection: {
@@ -60,7 +60,7 @@ export function prepareBaseResolvers(baseTC: DiscriminatorTypeComposer<any, any>
           });
           break;
 
-        case EMCResolvers.createMany:
+        case 'createMany':
           resolver.getOTC().extendField('records', {
             type: baseTC.getDInterface().List.NonNull,
             projection: {
@@ -69,7 +69,7 @@ export function prepareBaseResolvers(baseTC: DiscriminatorTypeComposer<any, any>
           });
           break;
 
-        case EMCResolvers.pagination:
+        case 'pagination':
           resolver.getOTC().extendField('items', {
             type: baseTC.getDInterface().List,
             projection: {
@@ -78,7 +78,7 @@ export function prepareBaseResolvers(baseTC: DiscriminatorTypeComposer<any, any>
           });
           break;
 
-        case EMCResolvers.connection:
+        case 'connection':
           const edgesTC = resolver
             .getOTC()
             .getFieldOTC('edges')
@@ -101,12 +101,12 @@ export function prepareBaseResolvers(baseTC: DiscriminatorTypeComposer<any, any>
 
       // set DKey as required field to create from base
       // must be done after setting DKeyEnum
-      if (resolverName === EMCResolvers.createOne || resolverName === EMCResolvers.createMany) {
-        const fieldName = resolverName === EMCResolvers.createMany ? 'records' : 'record';
+      if (resolverName === 'createOne' || resolverName === 'createMany') {
+        const fieldName = resolverName === 'createMany' ? 'records' : 'record';
         resolver.getArgITC(fieldName).extendField(baseTC.getDKey(), {
           type: baseTC.getDKeyETC().NonNull,
         });
       }
     }
-  }
+  });
 }

src/discriminators/prepareChildResolvers.ts

@@ -3,7 +3,7 @@ import {
   ComposeWithMongooseDiscriminatorsOpts,
   DiscriminatorTypeComposer,
 } from './DiscriminatorTypeComposer';
-import { EMCResolvers } from '../resolvers';
+import { availableResolverNames } 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,43 +136,43 @@ export function prepareChildResolvers<TSource, TContext>(
   childTC: ObjectTypeComposer<TSource, TContext>,
   opts: ComposeWithMongooseDiscriminatorsOpts<TContext>
 ): void {
-  for (const resolverName in EMCResolvers) {
-    if (EMCResolvers.hasOwnProperty(resolverName) && childTC.hasResolver(resolverName)) {
+  availableResolverNames.forEach((resolverName) => {
+    if (childTC.hasResolver(resolverName)) {
       const resolver = childTC.getResolver(resolverName);
 
       switch (resolverName) {
-        case EMCResolvers.createOne:
+        case 'createOne':
           setQueryDKey(resolver, childTC, baseDTC.getDKey(), 'record');
 
           hideDKey(resolver, childTC, baseDTC.getDKey(), 'record');
           break;
 
-        case EMCResolvers.createMany:
+        case 'createMany':
           setQueryDKey(resolver, childTC, baseDTC.getDKey(), 'records');
 
           hideDKey(resolver, childTC, baseDTC.getDKey(), 'records');
           break;
 
-        case EMCResolvers.updateById:
+        case 'updateById':
           hideDKey(resolver, childTC, baseDTC.getDKey(), 'record');
           break;
 
-        case EMCResolvers.updateOne:
-        case EMCResolvers.updateMany:
+        case 'updateOne':
+        case 'updateMany':
           setQueryDKey(resolver, childTC, baseDTC.getDKey(), 'filter');
 
           hideDKey(resolver, childTC, baseDTC.getDKey(), ['record', 'filter']);
           break;
 
-        case EMCResolvers.findOne:
-        case EMCResolvers.findMany:
-        case EMCResolvers.findOneLean:
-        case EMCResolvers.findManyLean:
-        case EMCResolvers.removeOne:
-        case EMCResolvers.removeMany:
-        case EMCResolvers.count:
-        case EMCResolvers.pagination:
-        case EMCResolvers.connection:
+        case 'findOne':
+        case 'findMany':
+        case 'findOneLean':
+        case 'findManyLean':
+        case 'removeOne':
+        case 'removeMany':
+        case 'count':
+        case 'pagination':
+        case 'connection':
           // limit remove scope to DKey
           setQueryDKey(resolver, childTC, baseDTC.getDKey(), 'filter');
 
@@ -189,5 +189,5 @@ export function prepareChildResolvers<TSource, TContext>(
         'records',
       ]);
     }
-  }
+  });
 }

src/discriminators/utils/__tests__/mergeTypeConverterResolverOpts-test.ts

@@ -1,12 +1,12 @@
-import type { TypeConverterResolversOpts } from '../../../composeWithMongoose';
 import {
   mergeTypeConverterResolverOpts,
   mergePrimitiveTypeFields,
   mergeMapTypeFields,
   mergeFilterOperatorsOptsMap,
 } from '../mergeTypeConverterResolversOpts';
+import { AllResolversOpts } from 'src/resolvers';
 
-const baseConverterResolverOpts: TypeConverterResolversOpts = {
+const baseConverterResolverOpts: AllResolversOpts = {
   findMany: {
     limit: { defaultValue: 20 },
     // sort: false,
@@ -33,7 +33,7 @@ const baseConverterResolverOpts: TypeConverterResolversOpts = {
   },
 };
 
-const childConverterResolverOpts: TypeConverterResolversOpts = {
+const childConverterResolverOpts: AllResolversOpts = {
   findMany: {
     limit: { defaultValue: 50 },
     sort: false,
@@ -59,7 +59,7 @@ const childConverterResolverOpts: TypeConverterResolversOpts = {
   },
 };
 
-const expectedConverterResolverOpts: TypeConverterResolversOpts = {
+const expectedConverterResolverOpts: AllResolversOpts = {
   findMany: {
     limit: { defaultValue: 50 },
     sort: false,

src/discriminators/utils/mergeTypeConverterResolversOpts.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-import type { TypeConverterResolversOpts } from '../../composeWithMongoose';
 import { MergeAbleHelperArgsOpts } from '../../resolvers/helpers';
 import { mergeStringAndStringArraysFields } from './mergeCustomizationOptions';
+import { AllResolversOpts } from 'src/resolvers';
 
 type TypeFieldMap = {
   [fieldName: string]: any;
@@ -126,9 +126,9 @@ export function mergeMapTypeFields(
 }
 
 export function mergeTypeConverterResolverOpts(
-  baseTypeConverterResolverOpts?: TypeConverterResolversOpts | false,
-  childTypeConverterResolverOpts?: TypeConverterResolversOpts | false
-): TypeConverterResolversOpts | false | void {
+  baseTypeConverterResolverOpts?: AllResolversOpts | false,
+  childTypeConverterResolverOpts?: AllResolversOpts | false
+): AllResolversOpts | false | void {
   if (!baseTypeConverterResolverOpts) {
     return childTypeConverterResolverOpts;
   }