feat: improve typescript definitions

Author: nodkz

src/__tests__/github_issues/260-test.ts

@@ -1,6 +1,7 @@
 import { schemaComposer, graphql } from 'graphql-compose';
 import { composeWithMongoose } from '../../index';
 import { mongoose } from '../../__mocks__/mongooseCommon';
+import { Document } from 'mongoose';
 
 const UserSchema = new mongoose.Schema({
   name: { type: String, required: true },
@@ -11,8 +12,18 @@ const PostSchema = new mongoose.Schema({
   reviewerIds: { type: [mongoose.Types.ObjectId] },
 });
 
-const UserModel = mongoose.model('User', UserSchema);
-const PostModel = mongoose.model('Post', PostSchema);
+interface IUser extends Document {
+  name: string;
+}
+
+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 = composeWithMongoose(UserModel);
 const PostTC = composeWithMongoose(PostModel);

src/composeWithMongoose.ts

@@ -39,10 +39,10 @@ export type TypeConverterInputTypeOpts = {
   };
 };
 
-export function composeWithMongoose<TSource = any, TContext = any>(
-  model: Model<any>,
+export function composeWithMongoose<TDoc extends Document, TContext = any>(
+  model: Model<TDoc>,
   opts: ComposeWithMongooseOpts<TContext> = {}
-): ObjectTypeComposer<TSource, TContext> {
+): ObjectTypeComposer<TDoc, TContext> {
   const m: Model<any> = model;
   const name: string = (opts && opts.name) || m.modelName;
 

src/composeWithMongooseDiscriminators.ts

@@ -1,13 +1,13 @@
 import { schemaComposer as globalSchemaComposer } from 'graphql-compose';
-import type { Model } from 'mongoose';
+import type { Model, Document } from 'mongoose';
 import { ComposeWithMongooseDiscriminatorsOpts, DiscriminatorTypeComposer } from './discriminators';
 
 export * from './discriminators';
 
-export function composeWithMongooseDiscriminators<TSource = any, TContext = any>(
-  baseModel: Model<any>,
+export function composeWithMongooseDiscriminators<TDoc extends Document, TContext = any>(
+  baseModel: Model<TDoc>,
   opts?: ComposeWithMongooseDiscriminatorsOpts<TContext>
-): DiscriminatorTypeComposer<TSource, TContext> {
+): DiscriminatorTypeComposer<TDoc, TContext> {
   const sc = opts?.schemaComposer || globalSchemaComposer;
   return DiscriminatorTypeComposer.createFromModel(baseModel, sc, opts);
 }

src/fieldsConverter.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-use-before-define */
 
-import mongoose from 'mongoose';
+import mongoose, { Document } from 'mongoose';
 import type { Schema, Model } from 'mongoose';
 import type {
   SchemaComposer,
@@ -130,11 +130,11 @@ export function getFieldsFromModel(model: Model<any> | MongoosePseudoModelT): Mo
   return fields;
 }
 
-export function convertModelToGraphQL<TSource, TContext>(
-  model: Model<any> | MongoosePseudoModelT,
+export function convertModelToGraphQL<TDoc extends Document, TContext>(
+  model: Model<TDoc> | MongoosePseudoModelT,
   typeName: string,
   schemaComposer: SchemaComposer<TContext>
-): ObjectTypeComposer<TSource, TContext> {
+): ObjectTypeComposer<TDoc, TContext> {
   const sc = schemaComposer;
 
   if (!typeName) {

src/resolvers/connection.ts

@@ -6,6 +6,7 @@ import type {
   ObjectTypeComposerFieldConfigMap,
 } from 'graphql-compose';
 import { getUniqueIndexes, extendByReversedIndexes, IndexT } from '../utils/getIndexesFromModel';
+import { ArgsMap } from './helpers';
 
 export type ConnectionOpts<TContext = any> = _ConnectionSortMapOpts & {
   edgeFields?: ObjectTypeComposerFieldConfigMap<any, TContext>;
@@ -15,11 +16,11 @@ export type ConnectionOpts<TContext = any> = _ConnectionSortMapOpts & {
   edgeTypeName?: string;
 };
 
-export default function connection<TSource = Document, TContext = any>(
-  model: Model<any>,
-  tc: ObjectTypeComposer<TSource, TContext>,
+export default function connection<TSource = any, TContext = any, TDoc extends Document = any>(
+  model: Model<TDoc>,
+  tc: ObjectTypeComposer<TDoc, TContext>,
   opts?: ConnectionOpts<TContext>
-): Resolver<TSource, TContext> | undefined {
+): Resolver<TSource, TContext, ArgsMap, TDoc> | undefined {
   try {
     require.resolve('graphql-compose-connection');
   } catch (e) {

src/resolvers/count.ts

@@ -1,18 +1,24 @@
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
-import { filterHelper, filterHelperArgs, prepareAliases, FilterHelperArgsOpts } from './helpers';
+import {
+  filterHelper,
+  filterHelperArgs,
+  prepareAliases,
+  FilterHelperArgsOpts,
+  ArgsMap,
+} from './helpers';
 import type { ExtendedResolveParams } from './index';
 import { beforeQueryHelper } from './helpers/beforeQueryHelper';
 
 export interface CountResolverOpts {
   filter?: FilterHelperArgsOpts | false;
 }
 
-export default function count<TSource = Document, TContext = any>(
-  model: Model<any>,
-  tc: ObjectTypeComposer<TSource, TContext>,
+export default function count<TSource = any, TContext = any, TDoc extends Document = any>(
+  model: Model<TDoc>,
+  tc: ObjectTypeComposer<TDoc, TContext>,
   opts?: CountResolverOpts
-): Resolver<TSource, TContext> {
+): Resolver<TSource, TContext, ArgsMap, TDoc> {
   if (!model || !model.modelName || !model.schema) {
     throw new Error('First arg for Resolver count() should be instance of Mongoose Model.');
   }
@@ -34,7 +40,7 @@ export default function count<TSource = Document, TContext = any>(
         ...opts?.filter,
       }),
     },
-    resolve: ((resolveParams: ExtendedResolveParams) => {
+    resolve: ((resolveParams: ExtendedResolveParams<TDoc>) => {
       resolveParams.query = model.find();
       resolveParams.model = model;
       filterHelper(resolveParams, aliases);
@@ -48,5 +54,5 @@ export default function count<TSource = Document, TContext = any>(
         return beforeQueryHelper(resolveParams);
       }
     }) as any,
-  });
+  }) as any;
 }

src/resolvers/createMany.ts

@@ -1,18 +1,18 @@
 import type { ObjectTypeComposer, Resolver } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
-import { recordHelperArgs, RecordHelperArgsOpts } from './helpers';
+import { recordHelperArgs, RecordHelperArgsOpts, ArgsMap } from './helpers';
 import { addErrorCatcherField } from './helpers/errorCatcher';
 import { validateManyAndThrow } from './helpers/validate';
 
 export interface CreateManyResolverOpts {
   records?: RecordHelperArgsOpts | false;
 }
 
-export default function createMany<TSource = Document, TContext = any>(
-  model: Model<any>,
-  tc: ObjectTypeComposer<TSource, TContext>,
+export default function createMany<TSource = any, TContext = any, TDoc extends Document = any>(
+  model: Model<TDoc>,
+  tc: ObjectTypeComposer<TDoc, TContext>,
   opts?: CreateManyResolverOpts
-): Resolver<TSource, TContext, any> {
+): Resolver<TSource, TContext, ArgsMap, TDoc> {
   if (!model || !model.modelName || !model.schema) {
     throw new Error('First arg for Resolver createMany() should be instance of Mongoose Model.');
   }
@@ -88,18 +88,18 @@ export default function createMany<TSource = Document, TContext = any>(
         }
       }
 
-      const docs = [];
+      const docs = [] as TDoc[];
       for (const record of recordData) {
         // eslint-disable-next-line new-cap
-        let doc: Document = new model(record);
+        let doc = new model(record);
         if (resolveParams.beforeRecordMutate) {
           doc = await resolveParams.beforeRecordMutate(doc, resolveParams);
         }
         docs.push(doc);
       }
 
       await validateManyAndThrow(docs);
-      await model.create(docs, { validateBeforeSave: false });
+      await model.create(docs as any, { validateBeforeSave: false });
 
       return {
         records: docs,
@@ -113,5 +113,5 @@ export default function createMany<TSource = Document, TContext = any>(
   // and return it in mutation payload
   addErrorCatcherField(resolver);
 
-  return resolver;
+  return resolver as any;
 }

src/resolvers/createOne.ts

@@ -1,6 +1,6 @@
 import { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
-import { recordHelperArgs, RecordHelperArgsOpts } from './helpers';
+import { recordHelperArgs, RecordHelperArgsOpts, ArgsMap } from './helpers';
 import type { ExtendedResolveParams } from './index';
 import { addErrorCatcherField } from './helpers/errorCatcher';
 import { validateAndThrow } from './helpers/validate';
@@ -9,11 +9,11 @@ export interface CreateOneResolverOpts {
   record?: RecordHelperArgsOpts | false;
 }
 
-export default function createOne<TSource = Document, TContext = any>(
-  model: Model<any>,
-  tc: ObjectTypeComposer<TSource, TContext>,
+export default function createOne<TSource = any, TContext = any, TDoc extends Document = any>(
+  model: Model<TDoc>,
+  tc: ObjectTypeComposer<TDoc, TContext>,
   opts?: CreateOneResolverOpts
-): Resolver<TSource, TContext> {
+): Resolver<TSource, TContext, ArgsMap, TDoc> {
   if (!model || !model.modelName || !model.schema) {
     throw new Error('First arg for Resolver createOne() should be instance of Mongoose Model.');
   }
@@ -64,7 +64,7 @@ export default function createOne<TSource = Document, TContext = any>(
         ...(opts && opts.record),
       }),
     },
-    resolve: (async (resolveParams: ExtendedResolveParams) => {
+    resolve: (async (resolveParams: ExtendedResolveParams<TDoc>) => {
       const recordData = resolveParams?.args?.record;
 
       if (!(typeof recordData === 'object') || Object.keys(recordData).length === 0) {
@@ -73,7 +73,7 @@ export default function createOne<TSource = Document, TContext = any>(
         );
       }
 
-      let doc: Document = new model(recordData);
+      let doc = new model(recordData);
       if (resolveParams.beforeRecordMutate) {
         doc = await resolveParams.beforeRecordMutate(doc, resolveParams);
         if (!doc) return null;
@@ -92,5 +92,5 @@ export default function createOne<TSource = Document, TContext = any>(
   // and return it in mutation payload
   addErrorCatcherField(resolver);
 
-  return resolver;
+  return resolver as any;
 }

src/resolvers/dataLoader.ts

@@ -1,14 +1,14 @@
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
-import { projectionHelper, prepareAliases } from './helpers';
+import { projectionHelper, prepareAliases, ArgsMap } from './helpers';
 import type { ExtendedResolveParams } from './index';
 import { beforeQueryHelper } from './helpers/beforeQueryHelper';
 import { getDataLoader } from './helpers/dataLoaderHelper';
 
-export default function dataLoader<TSource = Document, TContext = any>(
-  model: Model<any>,
-  tc: ObjectTypeComposer<TSource, TContext>
-): Resolver<TSource, TContext> {
+export default function dataLoader<TSource = any, TContext = any, TDoc extends Document = any>(
+  model: Model<TDoc>,
+  tc: ObjectTypeComposer<TDoc, TContext>
+): Resolver<TSource, TContext, ArgsMap, TDoc> {
   if (!model || !model.modelName || !model.schema) {
     throw new Error('First arg for Resolver dataLoader() should be instance of Mongoose Model.');
   }
@@ -28,7 +28,7 @@ export default function dataLoader<TSource = Document, TContext = any>(
     args: {
       _id: 'MongoID!',
     },
-    resolve: ((resolveParams: ExtendedResolveParams) => {
+    resolve: ((resolveParams: ExtendedResolveParams<TDoc>) => {
       const args = resolveParams.args || {};
 
       if (!args._id) {
@@ -44,7 +44,7 @@ export default function dataLoader<TSource = Document, TContext = any>(
       const dl = getDataLoader(resolveParams.context, resolveParams.info, (ids) => {
         resolveParams.query = model.find({
           _id: { $in: ids },
-        });
+        } as any);
         resolveParams.model = model;
         projectionHelper(resolveParams, aliases);
         return beforeQueryHelper(resolveParams) || [];

src/resolvers/dataLoaderLean.ts

@@ -1,14 +1,20 @@
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
-import { projectionHelper, prepareAliases, prepareAliasesReverse, replaceAliases } from './helpers';
+import {
+  projectionHelper,
+  prepareAliases,
+  prepareAliasesReverse,
+  replaceAliases,
+  ArgsMap,
+} from './helpers';
 import type { ExtendedResolveParams } from './index';
 import { beforeQueryHelperLean } from './helpers/beforeQueryHelper';
 import { getDataLoader } from './helpers/dataLoaderHelper';
 
-export default function dataLoaderLean<TSource = Document, TContext = any>(
-  model: Model<any>,
-  tc: ObjectTypeComposer<TSource, TContext>
-): Resolver<TSource, TContext> {
+export default function dataLoaderLean<TSource = any, TContext = any, TDoc extends Document = any>(
+  model: Model<TDoc>,
+  tc: ObjectTypeComposer<TDoc, TContext>
+): Resolver<TSource, TContext, ArgsMap, TDoc> {
   if (!model || !model.modelName || !model.schema) {
     throw new Error(
       'First arg for Resolver dataLoaderLean() should be instance of Mongoose Model.'
@@ -31,7 +37,7 @@ export default function dataLoaderLean<TSource = Document, TContext = any>(
     args: {
       _id: 'MongoID!',
     },
-    resolve: ((resolveParams: ExtendedResolveParams) => {
+    resolve: ((resolveParams: ExtendedResolveParams<TDoc>) => {
       const args = resolveParams.args || {};
 
       if (!args._id) {
@@ -47,7 +53,7 @@ export default function dataLoaderLean<TSource = Document, TContext = any>(
       const dl = getDataLoader(resolveParams.context, resolveParams.info, async (ids) => {
         resolveParams.query = model.find({
           _id: { $in: ids },
-        });
+        } as any);
         resolveParams.model = model;
         projectionHelper(resolveParams, aliases);
         const result = (await beforeQueryHelperLean(resolveParams)) || [];