build: fix eslint warnings

Author: nodkz

src/composeWithMongoose.ts

@@ -164,7 +164,7 @@ export function prepareFields(
     only?: string[];
     remove?: string[];
   }
-) {
+): void {
   if (Array.isArray(opts.only)) {
     const onlyFieldNames: string[] = opts.only;
     const removeFields = Object.keys(tc.getFields()).filter(
@@ -184,7 +184,7 @@ export function prepareInputFields(
     remove?: string[];
     required?: string[];
   }
-) {
+): void {
   if (Array.isArray(inputFieldsOpts.only)) {
     const onlyFieldNames: string[] = inputFieldsOpts.only;
     const removeFields = Object.keys(inputTypeComposer.getFields()).filter(

src/discriminators/DiscriminatorTypeComposer.ts

@@ -15,7 +15,7 @@ import { composeChildTC } from './composeChildTC';
 import { mergeCustomizationOptions } from './utils/mergeCustomizationOptions';
 import { prepareBaseResolvers } from './prepareBaseResolvers';
 import { reorderFields } from './utils/reorderFields';
-import { GraphQLFieldConfig } from 'graphql-compose/lib/graphql';
+import { GraphQLFieldConfig, GraphQLObjectType } from 'graphql-compose/lib/graphql';
 
 export interface ComposeWithMongooseDiscriminatorsOpts<TContext>
   extends ComposeWithMongooseOpts<TContext> {
@@ -75,15 +75,15 @@ export class DiscriminatorTypeComposer<TSource, TContext> extends ObjectTypeComp
   DInterface?: InterfaceTypeComposer<TSource, TContext>;
   DKeyETC?: EnumTypeComposer<TContext>;
 
-  constructor(gqType: any, schemaComposer: SchemaComposer<TContext>) {
+  constructor(gqType: GraphQLObjectType, schemaComposer: SchemaComposer<TContext>) {
     super(gqType, schemaComposer);
     return this;
   }
 
   static createFromModel<TSrc = any, TCtx = any>(
     baseModel: Model<any>,
     schemaComposer: SchemaComposer<TCtx>,
-    opts?: any
+    opts?: ComposeWithMongooseDiscriminatorsOpts<any>
   ): DiscriminatorTypeComposer<TSrc, TCtx> {
     if (!baseModel || !baseModel.discriminators) {
       throw Error('Discriminator Key not Set, Use composeWithMongoose for Normal Collections');

src/discriminators/__mocks__/characterModels.ts

@@ -11,7 +11,7 @@ const enumCharacterType = {
 export const CharacterObject = {
   _id: {
     type: String,
-    default: () => new Types.ObjectId(),
+    default: (): any => new Types.ObjectId(),
   },
   name: String,
 
@@ -33,7 +33,9 @@ export const CharacterObject = {
 const CharacterSchema = new Schema(CharacterObject);
 const ACharacterSchema = new Schema({ ...CharacterObject });
 
-export function getCharacterModels(DKey: string) {
+export function getCharacterModels(
+  DKey: string
+): { CharacterModel: Model<any>; PersonModel: Model<any>; DroidModel: Model<any> } {
   CharacterSchema.set('discriminatorKey', DKey);
 
   const CharacterModel: Model<any> = mongoose.models.Character
@@ -51,7 +53,7 @@ export function getCharacterModels(DKey: string) {
   return { CharacterModel, PersonModel, DroidModel };
 }
 
-export function getCharacterModelClone() {
+export function getCharacterModelClone(): { NoDKeyCharacterModel: Model<any> } {
   const NoDKeyCharacterModel = mongoose.model('NoDKeyCharacter', ACharacterSchema);
 
   /*

src/discriminators/prepareBaseResolvers.ts

@@ -27,7 +27,7 @@ function setDKeyEnumOnITCArgs(resolver: Resolver, baseTC: DiscriminatorTypeCompo
 // recomposing sets up the DInterface as the return types for
 // 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>) {
+export function prepareBaseResolvers(baseTC: DiscriminatorTypeComposer<any, any>): void {
   for (const resolverName in EMCResolvers) {
     if (EMCResolvers.hasOwnProperty(resolverName) && baseTC.hasResolver(resolverName)) {
       const resolver = baseTC.getResolver(resolverName);

src/discriminators/prepareChildResolvers.ts

@@ -135,7 +135,7 @@ export function prepareChildResolvers<TSource, TContext>(
   baseDTC: DiscriminatorTypeComposer<TSource, TContext>,
   childTC: ObjectTypeComposer<TSource, TContext>,
   opts: ComposeWithMongooseDiscriminatorsOpts<TContext>
-) {
+): void {
   for (const resolverName in EMCResolvers) {
     if (EMCResolvers.hasOwnProperty(resolverName) && childTC.hasResolver(resolverName)) {
       const resolver = childTC.getResolver(resolverName);

src/discriminators/utils/mergeTypeConverterResolversOpts.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 import type { TypeConverterResolversOpts } from '../../composeWithMongoose';
 import { MergeAbleHelperArgsOpts } from '../../resolvers/helpers';
 import { mergeStringAndStringArraysFields } from './mergeCustomizationOptions';
@@ -31,9 +32,9 @@ export function mergePrimitiveTypeFields(
 export function mergeFilterOperatorsOptsMap(
   baseFilterOperatorField: TypeFieldMap,
   childFilterOperatorField?: TypeFieldMap
-) {
+): TypeFieldMap {
   const baseOptsKeys = Object.keys(baseFilterOperatorField);
-  const baseOptsTypes = {} as Record<string, any>;
+  const baseOptsTypes = {} as TypeFieldMap;
   for (const key of baseOptsKeys) {
     baseOptsTypes[key] = 'string[]';
   }
@@ -49,7 +50,13 @@ export function mergeFilterOperatorsOptsMap(
   return childFilterOperatorField;
 }
 
-export function mergeArraysTypeFields(baseField: any, childField: any, argOptsType: TypeFieldMap) {
+export function mergeArraysTypeFields(
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  baseField: any,
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  childField: any,
+  argOptsType: TypeFieldMap
+): TypeFieldMap {
   let merged = childField !== undefined ? childField : {};
   if (Array.isArray(argOptsType)) {
     for (const argType of argOptsType) {
@@ -68,7 +75,11 @@ export function mergeArraysTypeFields(baseField: any, childField: any, argOptsTy
   return merged;
 }
 
-export function mergeMapTypeFields(baseField: any, childField: any, argOptsTypes: TypeFieldMap) {
+export function mergeMapTypeFields(
+  baseField: TypeFieldMap,
+  childField: TypeFieldMap | undefined,
+  argOptsTypes: TypeFieldMap
+): TypeFieldMap {
   const merged = childField === undefined ? {} : childField;
 
   if (argOptsTypes !== null && typeof argOptsTypes === 'object') {

src/discriminators/utils/reorderFields.ts

@@ -6,7 +6,7 @@ export function reorderFields<TContext>(
   order: string[] | boolean | undefined,
   DKey: string,
   commonFieldKeys?: string[]
-) {
+): DiscriminatorTypeComposer<any, TContext> | ObjectTypeComposer<any, TContext> {
   if (order) {
     if (Array.isArray(order)) {
       modelTC.reorderFields(order);

src/resolvers/createMany.ts

@@ -59,15 +59,15 @@ export default function createMany<TSource = Document, TContext = any>(
     t.addFields({
       recordIds: {
         type: '[MongoID!]!',
-        description: 'Created document ID',
+        description: 'Created document IDs',
       },
       records: {
         type: tc.NonNull.List,
         description: 'Created documents',
       },
       createCount: {
         type: 'Int!',
-        description: 'Count of all documents created',
+        description: 'Number of created documents',
       },
     });
   });

src/resolvers/findById.ts

@@ -1,13 +1,13 @@
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
 import { projectionHelper, prepareAliases } from './helpers';
-import type { ExtendedResolveParams, GenResolverOpts } from './index';
+import type { ExtendedResolveParams } from './index';
 import { beforeQueryHelper } from './helpers/beforeQueryHelper';
 
 export default function findById<TSource = Document, TContext = any>(
   model: Model<any>,
-  tc: ObjectTypeComposer<TSource, TContext>,
-  _opts?: GenResolverOpts // eslint-disable-line no-unused-vars
+  tc: ObjectTypeComposer<TSource, TContext>
+  // _opts?: GenResolverOpts
 ): Resolver<TSource, TContext> {
   if (!model || !model.modelName || !model.schema) {
     throw new Error('First arg for Resolver findById() should be instance of Mongoose Model.');

src/resolvers/helpers/filter.ts

@@ -24,7 +24,7 @@ export type FilterHelperArgsOpts = {
 };
 
 // for merging, discriminators merge-able only
-export const getFilterHelperArgOptsMap = () => ({
+export const getFilterHelperArgOptsMap = (): Record<string, string | string[]> => ({
   // filterTypeName? : 'string'
   isRequired: 'boolean',
   onlyIndexed: 'boolean',