[WIP] - Feature: Discriminator Support on composeMongoose

.eslintrc.js

@@ -9,6 +9,7 @@ module.exports = {
     useJSXTextNode: true,
     project: [path.resolve(__dirname, 'tsconfig.json')],
   },
+  root: true,
   rules: {
     'no-underscore-dangle': 0,
     'arrow-body-style': 0,

.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/__mocks__/mongooseCommon.ts

@@ -10,7 +10,7 @@ mongoose.Promise = Promise;
 const originalConnect = mongoose.connect;
 mongoose.createConnection = (async () => {
   const mongoServer = await MongoMemoryServer.create();
-  const mongoUri = mongoServer.getUri();
+  const mongoUri = await mongoServer.getUri();
 
   // originalConnect.bind(mongoose)(mongoUri, { useMongoClient: true }); // mongoose 4
   originalConnect.bind(mongoose)(mongoUri, {

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,6 +1,12 @@
-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';
 import { convertModelToGraphQL } from './fieldsConverter';
 import { resolverFactory } from './resolvers';
 import MongoID from './types/MongoID';
@@ -71,6 +77,15 @@ export type ComposeMongooseOpts<TContext = any> = {
    * You can make fields as NonNull if they have default value in mongoose model.
    */
   defaultsAsNonNull?: boolean;
+  /**
+   * Support discriminators on base models
+   */
+  includeBaseDiscriminators?: boolean;
+  /**
+   * EXPERIMENTAL - Support discriminated fields on nested fields
+   * May not work as expected on input types for mutations
+   */
+  includeNestedDiscriminators?: boolean;
 
   /** @deprecated */
   fields?: {
@@ -101,7 +116,7 @@ export type GenerateResolverType<TDoc extends Document, TContext = any> = {
 export function composeMongoose<TDoc extends Document, TContext = any>(
   model: Model<TDoc>,
   opts: ComposeMongooseOpts<TContext> = {}
-): ObjectTypeComposer<TDoc, TContext> & {
+): (ObjectTypeComposer<TDoc, TContext> | EDiscriminatorTypeComposer<TDoc, TContext>) & {
   mongooseResolvers: GenerateResolverType<TDoc, TContext>;
 } {
   const m: Model<any> = model;
@@ -121,7 +136,7 @@ export function composeMongoose<TDoc extends Document, TContext = any>(
     sc.delete(m.schema);
   }
 
-  const tc = convertModelToGraphQL(m, name, sc);
+  const tc = convertModelToGraphQL(m, name, sc, { ...opts });
 
   if (opts.description) {
     tc.setDescription(opts.description);
@@ -152,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;
@@ -188,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;
@@ -202,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/discriminators/__mocks__/characterModels.ts

@@ -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>;

src/discriminators/prepareBaseResolvers.ts

@@ -76,7 +76,7 @@ export function prepareBaseResolvers(baseTC: DiscriminatorTypeComposer<any, any>
           });
           break;
 
-        case 'connection':
+        case 'connection': {
           const edgesTC = resolver
             .getOTC()
             .getFieldOTC('edges')
@@ -91,6 +91,7 @@ export function prepareBaseResolvers(baseTC: DiscriminatorTypeComposer<any, any>
 
           resolver.getOTC().setField('edges', edgesTC.NonNull.List.NonNull);
           break;
+        }
 
         default:
       }

src/enhancedDiscriminators/__mocks__/characterDiscrimModels.ts

@@ -0,0 +1,97 @@
+import type { Model } from 'mongoose';
+import { mongoose, Schema, Types } from '../../__mocks__/mongooseCommon';
+
+export const PersonSchema = new Schema({
+  dob: Number,
+  primaryFunction: [String],
+  starShips: [String],
+  totalCredits: Number,
+});
+
+export const DroidSchema = new Schema({
+  makeDate: Date,
+  modelNumber: Number,
+  primaryFunction: [String],
+});
+
+const MovieSchema = new Schema({
+  _id: String,
+
+  characters: {
+    type: [String], // redundant but i need it.
+    description: 'A character in the Movie, Person or Droid.',
+  },
+
+  director: {
+    type: String, // id of director
+    description: 'Directed the movie.',
+  },
+
+  imdbRatings: String,
+  releaseDate: String,
+});
+
+export const MovieModel = mongoose.model('Movie', MovieSchema);
+
+const enumCharacterType = {
+  PERSON: 'Person',
+  DROID: 'Droid',
+};
+
+export const CharacterObject = {
+  _id: {
+    type: String,
+    default: (): any => new Types.ObjectId(),
+  },
+  name: String,
+
+  type: {
+    type: String,
+    require: true,
+    enum: Object.keys(enumCharacterType),
+  },
+  kind: {
+    type: String,
+    require: true,
+    enum: Object.keys(enumCharacterType),
+  },
+
+  friends: [String], // another Character
+  appearsIn: [String], // movie
+};
+
+export function getCharacterModels(
+  DKey?: string,
+  name: string = 'Character'
+): { CharacterModel: Model<any>; PersonModel: Model<any>; DroidModel: Model<any> } {
+  const CharacterSchema = DKey
+    ? new Schema(CharacterObject, { discriminatorKey: DKey })
+    : new Schema(CharacterObject);
+
+  const CharacterModel: Model<any> = mongoose.model(name, CharacterSchema);
+
+  const PersonModel: Model<any> = CharacterModel.discriminator(
+    name + enumCharacterType.PERSON,
+    PersonSchema
+  );
+
+  const DroidModel: Model<any> = CharacterModel.discriminator(
+    name + enumCharacterType.DROID,
+    DroidSchema
+  );
+
+  return { CharacterModel, PersonModel, DroidModel };
+}
+
+export function getCharacterModelClone(): { NoDKeyCharacterModel: Model<any> } {
+  const ACharacterSchema = new Schema({ ...CharacterObject });
+  const NoDKeyCharacterModel = mongoose.model('NoDKeyCharacter', ACharacterSchema);
+
+  /*
+    const APersonModel = ACharacterModel.discriminator('A' + enumCharacterType.PERSON, PersonSchema.clone());
+
+    const ADroidModel = ACharacterModel.discriminator('A' + enumCharacterType.DROID, DroidSchema.clone());
+  */
+
+  return { NoDKeyCharacterModel }; // APersonModel, ADroidModel };
+}