[WIP] - Feature: Discriminator Support on composeMongoose

src/composeMongoose.ts

@@ -1,6 +1,7 @@
 import type { SchemaComposer, Resolver, InputTypeComposer } 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 +72,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 +111,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 +131,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);

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 };
+}