Change eDTC to extend InterfaceTypeComposer and fix various resulting type errors

Author: jhbuchanan45

.vscode/settings.json

@@ -6,5 +6,5 @@
   "typescript.format.enable": false,
   "editor.codeActionsOnSave": {
     "source.fixAll.eslint": true
-  },
+  }
 }

package.json

@@ -42,7 +42,7 @@
     "eslint-plugin-import": "2.23.4",
     "eslint-plugin-prettier": "3.4.0",
     "graphql": "15.5.1",
-    "graphql-compose": "9.0.1",
+    "graphql-compose": "9.0.2",
     "jest": "27.0.6",
     "mongodb-memory-server": "7.3.2",
     "mongoose": "5.13.3",

src/__tests__/github_issues/260-test.ts

@@ -1,4 +1,4 @@
-import { schemaComposer, graphql } from 'graphql-compose';
+import { schemaComposer, graphql, ObjectTypeComposer } from 'graphql-compose';
 import { composeMongoose } from '../../index';
 import { mongoose } from '../../__mocks__/mongooseCommon';
 import { Document } from 'mongoose';
@@ -28,6 +28,10 @@ const PostModel = mongoose.model<IPost>('Post', PostSchema);
 const UserTC = composeMongoose(UserModel);
 const PostTC = composeMongoose(PostModel);
 
+if (!(UserTC instanceof ObjectTypeComposer) || !(PostTC instanceof ObjectTypeComposer)) {
+  throw new Error('TCs should return ObjectTypeComposers');
+}
+
 PostTC.addRelation('author', {
   resolver: UserTC.mongooseResolvers.dataLoader({
     lean: true, // <---- `Lean` loads record from DB without support of mongoose getters & virtuals

src/__tests__/github_issues/263-test.ts

@@ -1,4 +1,4 @@
-import { schemaComposer, graphql } from 'graphql-compose';
+import { schemaComposer, graphql, ObjectTypeComposer } from 'graphql-compose';
 import { composeMongoose } from '../../index';
 import { mongoose } from '../../__mocks__/mongooseCommon';
 
@@ -28,6 +28,10 @@ const PostModel = mongoose.model<IPost>('Post', PostSchema);
 const UserTC = composeMongoose(UserModel);
 const PostTC = composeMongoose(PostModel);
 
+if (!(UserTC instanceof ObjectTypeComposer) || !(PostTC instanceof ObjectTypeComposer)) {
+  throw new Error('TCs should return ObjectTypeComposers');
+}
+
 PostTC.addRelation('author', {
   resolver: UserTC.mongooseResolvers.dataLoader({ lean: true }),
   prepareArgs: {

src/composeMongoose.ts

@@ -1,4 +1,9 @@
-import type { SchemaComposer, Resolver, InputTypeComposer } from 'graphql-compose';
+import type {
+  SchemaComposer,
+  Resolver,
+  InputTypeComposer,
+  InterfaceTypeComposer,
+} from 'graphql-compose';
 import { schemaComposer as globalSchemaComposer, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
 import { EDiscriminatorTypeComposer } from './enhancedDiscriminators';
@@ -162,7 +167,7 @@ export function composeMongoose<TDoc extends Document, TContext = any>(
 }
 
 function makeFieldsNonNullWithDefaultValues(
-  tc: ObjectTypeComposer,
+  tc: ObjectTypeComposer | InterfaceTypeComposer,
   alreadyWorked = new Set()
 ): void {
   if (alreadyWorked.has(tc)) return;
@@ -198,7 +203,7 @@ function makeFieldsNonNullWithDefaultValues(
 }
 
 export function prepareFields(
-  tc: ObjectTypeComposer<any, any>,
+  tc: ObjectTypeComposer<any, any> | InterfaceTypeComposer<any, any>,
   opts: ComposeMongooseOpts<any> = {}
 ): void {
   const onlyFields = opts?.onlyFields || opts?.fields?.only;
@@ -212,7 +217,7 @@ export function prepareFields(
 }
 
 export function createInputType(
-  tc: ObjectTypeComposer<any, any>,
+  tc: ObjectTypeComposer<any, any> | InterfaceTypeComposer<any, any>,
   inputTypeOpts: TypeConverterInputTypeOpts = {}
 ): void {
   const inputTypeComposer = tc.getInputTypeComposer();

src/composeWithMongoose.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-use-before-define, no-param-reassign, global-require */
 
-import type { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
-import { schemaComposer as globalSchemaComposer } from 'graphql-compose';
+import type { SchemaComposer } from 'graphql-compose';
+import { ObjectTypeComposer, schemaComposer as globalSchemaComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
 import { convertModelToGraphQL } from './fieldsConverter';
 import { resolverFactory, AllResolversOpts } from './resolvers';
@@ -53,6 +53,13 @@ export function composeWithMongoose<TDoc extends Document, TContext = any>(
 
   const tc = convertModelToGraphQL(m, name, sc);
 
+  if (!(tc instanceof ObjectTypeComposer)) {
+    // should be impossible I hope
+    throw new Error(
+      'composeWithMongoose does not support discriminator mode, use composeMongoose or composeWithMongooseDiscriminators instead'
+    );
+  }
+
   if (opts.description) {
     tc.setDescription(opts.description);
   }

src/enhancedDiscriminators/__tests__/eDiscriminatorTypeComposer-test.ts

@@ -30,34 +30,32 @@ const composeMongoose = <TDoc extends Document, TContext = any>(
   return generatedTC;
 };
 
-let baseDTC: EDiscriminatorTypeComposer<any, any>;
-let DInterface: InterfaceTypeComposer<any, any>;
+let eDTC: EDiscriminatorTypeComposer<any, any>;
 let DInputObject: ObjectTypeComposer<any, any>;
 
 beforeEach(() => {
-  baseDTC = composeMongoose(CharacterModel);
-  DInterface = schemaComposer.getIFTC(baseDTC.getTypeName());
-  DInputObject = baseDTC.getDInputObject();
+  eDTC = composeMongoose(CharacterModel);
+  DInputObject = eDTC.getDInputObject();
 });
 
 afterEach(() => {
-  baseDTC.schemaComposer.clear();
+  eDTC.schemaComposer.clear();
 });
 
 describe('EDiscriminatorTypeComposer', () => {
-  it('has an interface object DInterface as the type name', () => {
-    expect(baseDTC.getDInterface()).toEqual(schemaComposer.getAnyTC(baseDTC.getTypeName()));
-  });
-
   it('throws an error when default (__t) discriminator key is set', () => {
-    baseDTC.schemaComposer.clear();
+    eDTC.schemaComposer.clear();
     const { CharacterModel: noDKeyModel } = getCharacterModels(undefined, 'noDKeyCharacter');
     const errorCall = () => composeMongoose(noDKeyModel);
     expect(errorCall).toThrowError(
       'A custom discriminator key must be set on the model options in mongoose for discriminator behaviour to function correctly'
     );
   });
 
+  it('should have type resolvers for discriminated models', () => {
+    expect(eDTC.getTypeResolverNames()).toHaveLength(2);
+  });
+
   it('should not be used on models without discriminators', () => {
     const { DroidModel } = getCharacterModels(undefined, 'noDiscrim');
     const noDiscrim = composeMongooseRaw(DroidModel, dComposeOpts);
@@ -66,15 +64,11 @@ describe('EDiscriminatorTypeComposer', () => {
 
   describe('Custom Getters', () => {
     test('getting discriminator key', () => {
-      expect(baseDTC.getDKey()).toEqual(defaultDKey);
-    });
-
-    test('getting discriminator interface', () => {
-      expect(baseDTC.getDInterface()).toBe(DInterface);
+      expect(eDTC.getDKey()).toEqual(defaultDKey);
     });
 
     test('getting discriminator input object TC', () => {
-      expect(baseDTC.getDInputObject()).toBe(DInputObject);
+      expect(eDTC.getDInputObject()).toBe(DInputObject);
     });
   });
 
@@ -102,35 +96,33 @@ describe('EDiscriminatorTypeComposer', () => {
     });
   });
 
-  describe('DInterface', () => {
+  describe('eDTC', () => {
     it('shares field names with base model used to compose it', () => {
-      expect(DInterface.getFieldNames()).toEqual(
+      expect(eDTC.getFieldNames()).toEqual(
         expect.arrayContaining(
           Object.keys(CharacterModel.schema.paths).filter((x) => !x.startsWith('__'))
         )
       );
     });
 
     it('should be an instance of InterfaceTypeComposer', () => {
-      expect(DInterface instanceof InterfaceTypeComposer).toBeTruthy();
+      expect(eDTC instanceof InterfaceTypeComposer).toBeTruthy();
     });
 
     it('should have the input TC from DInputObject as input TC', () => {
-      expect(DInterface.getInputTypeComposer()).toEqual(
-        baseDTC.getDInputObject().getInputTypeComposer()
-      );
+      expect(eDTC.getInputTypeComposer()).toEqual(eDTC.getDInputObject().getInputTypeComposer());
     });
   });
 
   describe('Get Discriminator TCs', () => {
     it('returns discrimTCs with mongooseResolvers present', () => {
-      Object.values(baseDTC.getDiscriminatorTCs()).forEach((discimTC) => {
+      Object.values(eDTC.getDiscriminatorTCs()).forEach((discimTC) => {
         expect(discimTC).toHaveProperty('mongooseResolvers');
       });
     });
     it('returns empty object with mongooseResolvers missing', () => {
-      (baseDTC.discrimTCs[Object.keys(baseDTC.discrimTCs)[0]] as any).mongooseResolvers = undefined;
-      Object.values(baseDTC.getDiscriminatorTCs()).forEach((discimTC) => {
+      (eDTC.discrimTCs[Object.keys(eDTC.discrimTCs)[0]] as any).mongooseResolvers = undefined;
+      Object.values(eDTC.getDiscriminatorTCs()).forEach((discimTC) => {
         expect(discimTC).toHaveProperty('mongooseResolvers');
       });
     });
@@ -139,71 +131,63 @@ describe('EDiscriminatorTypeComposer', () => {
   describe('Overridden eDTC Class Methods', () => {
     describe('Set Field', () => {
       it('updates field on all child TCs', () => {
-        baseDTC.setField('newField', 'String');
-        expect(baseDTC.hasField('newField')).toBeTruthy();
-        expect(DInterface.hasField('newField')).toBeTruthy();
+        eDTC.setField('newField', 'String');
+        expect(eDTC.hasField('newField')).toBeTruthy();
         expect(DInputObject.hasField('newField')).toBeTruthy();
-        Object.values(baseDTC.discrimTCs).forEach((dTC) => {
+        Object.values(eDTC.discrimTCs).forEach((dTC) => {
           expect(dTC.hasField('newField')).toBeTruthy();
         });
       });
 
       it('updates input TC when field is added', () => {
-        baseDTC.setField('inputField', 'String');
-        expect(schemaComposer.getIFTC(baseDTC.getTypeName()).getInputTypeComposer()).toEqual(
+        eDTC.setField('inputField', 'String');
+        expect(schemaComposer.getIFTC(eDTC.getTypeName()).getInputTypeComposer()).toEqual(
           DInputObject.getInputTypeComposer()
         );
       });
     });
 
     describe('Set Extensions', () => {
       it('updates field on all child TCs', () => {
-        baseDTC.setExtensions({ newField: 'testExtension' });
-        expect(baseDTC.hasExtension('newField')).toBeTruthy();
-        expect(DInterface.hasExtension('newField')).toBeTruthy();
+        eDTC.setExtensions({ newField: 'testExtension' });
+        expect(eDTC.hasExtension('newField')).toBeTruthy();
         expect(DInputObject.hasExtension('newField')).toBeTruthy();
-        Object.values(baseDTC.discrimTCs).forEach((dTC) => {
+        Object.values(eDTC.discrimTCs).forEach((dTC) => {
           expect(dTC.hasExtension('newField')).toBeTruthy();
         });
       });
     });
 
     describe('Remove Field', () => {
       it('deletes field on all child TCs', () => {
-        baseDTC.addFields({ toDelete: 'String' });
+        eDTC.addFields({ toDelete: 'String' });
         // check field added
-        expect(baseDTC.hasField('toDelete')).toBeTruthy();
-        expect(DInterface.hasField('toDelete')).toBeTruthy();
+        expect(eDTC.hasField('toDelete')).toBeTruthy();
         expect(DInputObject.hasField('toDelete')).toBeTruthy();
-        Object.values(baseDTC.discrimTCs).forEach((dTC) => {
+        Object.values(eDTC.discrimTCs).forEach((dTC) => {
           expect(dTC.hasField('toDelete')).toBeTruthy();
         });
 
-        baseDTC.removeField('toDelete');
-        expect(baseDTC.hasField('toDelete')).toBeFalsy();
-        expect(DInterface.hasField('toDelete')).toBeFalsy();
+        eDTC.removeField('toDelete');
+        expect(eDTC.hasField('toDelete')).toBeFalsy();
         expect(DInputObject.hasField('toDelete')).toBeFalsy();
-        Object.values(baseDTC.discrimTCs).forEach((dTC) => {
+        Object.values(eDTC.discrimTCs).forEach((dTC) => {
           expect(dTC.hasField('toDelete')).toBeFalsy();
         });
       });
     });
 
     describe('Remove Other Fields', () => {
       it('removes all other fields from base TC from all child TCs', () => {
-        baseDTC.addFields({ toKeep: 'String' });
+        eDTC.addFields({ toKeep: 'String' });
 
-        const otherFields = baseDTC
-          .getDInterface()
-          .getFieldNames()
-          .filter((field) => field !== 'toKeep');
-        baseDTC.removeOtherFields('toKeep');
+        const otherFields = eDTC.getFieldNames().filter((field) => field !== 'toKeep');
+        eDTC.removeOtherFields('toKeep');
 
         otherFields.forEach((removedField) => {
-          expect(baseDTC.hasField(removedField)).toBeFalsy();
-          expect(DInterface.hasField(removedField)).toBeFalsy();
+          expect(eDTC.hasField(removedField)).toBeFalsy();
           expect(DInputObject.hasField(removedField)).toBeFalsy();
-          Object.values(baseDTC.discrimTCs).forEach((dTC) => {
+          Object.values(eDTC.discrimTCs).forEach((dTC) => {
             expect(dTC.hasField(removedField)).toBeFalsy();
           });
         });
@@ -215,42 +199,39 @@ describe('EDiscriminatorTypeComposer', () => {
         const fieldOrder = ['_id', 'appearsIn', 'friends', 'kind', 'type'];
         const fieldOrderString = fieldOrder.join('');
 
-        baseDTC.reorderFields(fieldOrder);
+        eDTC.reorderFields(fieldOrder);
 
-        expect(baseDTC.getFieldNames().join('').startsWith(fieldOrderString)).toBeTruthy();
-        expect(DInterface.getFieldNames().join('').startsWith(fieldOrderString)).toBeTruthy();
+        expect(eDTC.getFieldNames().join('').startsWith(fieldOrderString)).toBeTruthy();
         expect(DInputObject.getFieldNames().join('').startsWith(fieldOrderString)).toBeTruthy();
-        Object.values(baseDTC.discrimTCs).forEach((dTC) => {
+        Object.values(eDTC.discrimTCs).forEach((dTC) => {
           expect(dTC.getFieldNames().join('').startsWith(fieldOrderString)).toBeTruthy();
         });
       });
     });
 
     describe('Make Fields Nullable/Non-null', () => {
       it('makes a nullable field non-null', () => {
-        baseDTC.addFields({ initialNullable: 'String' });
-        expect(baseDTC.isFieldNonNull('initialNullable')).toBeFalsy();
+        eDTC.addFields({ initialNullable: 'String' });
+        expect(eDTC.isFieldNonNull('initialNullable')).toBeFalsy();
 
-        baseDTC.makeFieldNonNull('initialNullable');
+        eDTC.makeFieldNonNull('initialNullable');
 
-        expect(baseDTC.isFieldNonNull('initialNullable')).toBeTruthy();
-        expect(DInterface.isFieldNonNull('initialNullable')).toBeTruthy();
+        expect(eDTC.isFieldNonNull('initialNullable')).toBeTruthy();
         expect(DInputObject.isFieldNonNull('initialNullable')).toBeTruthy();
-        Object.values(baseDTC.discrimTCs).forEach((dTC) => {
+        Object.values(eDTC.discrimTCs).forEach((dTC) => {
           expect(dTC.isFieldNonNull('initialNullable')).toBeTruthy();
         });
       });
 
       it('makes a non-null field nullable', () => {
-        baseDTC.addFields({ initialNonNull: 'String!' });
-        expect(baseDTC.isFieldNonNull('initialNonNull')).toBeTruthy();
+        eDTC.addFields({ initialNonNull: 'String!' });
+        expect(eDTC.isFieldNonNull('initialNonNull')).toBeTruthy();
 
-        baseDTC.makeFieldNullable('initialNonNull');
+        eDTC.makeFieldNullable('initialNonNull');
 
-        expect(baseDTC.isFieldNonNull('initialNonNull')).toBeFalsy();
-        expect(DInterface.isFieldNonNull('initialNonNull')).toBeFalsy();
+        expect(eDTC.isFieldNonNull('initialNonNull')).toBeFalsy();
         expect(DInputObject.isFieldNonNull('initialNonNull')).toBeFalsy();
-        Object.values(baseDTC.discrimTCs).forEach((dTC) => {
+        Object.values(eDTC.discrimTCs).forEach((dTC) => {
           expect(dTC.isFieldNonNull('initialNonNull')).toBeFalsy();
         });
       });