Mongoose and Discriminators

[MDrooker]

I have a schema that uses mongoose discriminators for a few objects. One example is -

let baseFollowSchema = mongoose.Schema({
    followuuid: { type: String, default: uuidv4() },
    createdDate: { type: Date, default: Date.now },
    effectiveStartDate: { type: Date, default: Date.now },
    effectiveEndDate: { type: Date, default: new Date(+new Date() + 30 * 24 * 60 * 60 * 1000) }, // 30 days
    metadata: [metaDataItemSchema],
    reviewData: [reviewDataItemSchema],
    isActive: { type: Boolean, default: true },
    isDeleted: { type: Boolean, default: false }
}, { discriminatorKey: 'followType' })
let Follow = mongoose.model('baseFollowSchema', baseFollowSchema, 'follow');


let KnowledgeGraphFollow = Follow.discriminator('followKGEntity',
    new mongoose.Schema({
        name: { type: String },
        followedKGIDs: [{
            kgid: { type: String },
            entityType: { type: String },
            name: { type: String },
            metadata: [metaDataItemSchema]
        }]
    })
);

[.... Other models excluded for simplicity]

Is there a good example/test that can point me to how to implement the use of discriminators?
Thanks-
MJD

[asabhaney]

+1

[MDrooker]

Any thoughts/links to help the request above?

[nodkz]

Check this test-case

graphql-compose-mongoose/src/__tests__/github-issues-test.js

Lines 7 to 20 in ced7730

	it('#78 Mongoose and Discriminators', () => {
	const options = { discriminatorKey: 'kind' };
	const eventSchema = new mongoose.Schema({ time: Date }, options);
	const Event = mongoose.model('GenericEvent', eventSchema);
	const clickedLinkSchema = new mongoose.Schema({ url: String }, options);
	const ClickedLinkEvent = Event.discriminator('ClickedLinkEvent', clickedLinkSchema);
	const EventTC = composeWithMongoose(Event);
	const ClickedLinkEventTC = composeWithMongoose(ClickedLinkEvent);
	expect(EventTC.getFieldNames()).toEqual(['time', '_id', 'kind']);
	expect(ClickedLinkEventTC.getFieldNames()).toEqual(['url', '_id', 'time', 'kind']);

Use "discriminated" model as a usual model on which can be called composeWithMongoose method for obtaining new GraphQL type.

If you want to remove discriminatorKey field (in my test case kind fieldname):

// completely remove `kind` field from all generated types/sub-types
ClickedLinkEventTC = composeWithMongoose(ClickedLinkEvent, { fields: { remove: ['kind'] } });

// Or remove it just from OutputType
ClickedLinkEventTC.removeField('kind');

// Or remove it just from InputType
ClickedLinkEventTC.getInputTypeComposer().removeField('kind');

// Don't worry, field `kind` will be hidden only in GraphQL. In mongoose, it stays as is.

[MDrooker]

Great-
How would a Resolver look since the return type can now be two different 'typeConverted' schemas. And I didnt see where the we can have that be multiple.

[nodkz]

@MDrooker It very interesting to me how do you get a list of Events and then convert some of them to extended ClickedLinkEvent with regular mongoose code? How I know mongoose cannot do this, or i'm wrong?

[MDrooker]

Mongoose converts to the proper model based on the Discriminator Key...
So this example will return true based on the StoryFollow being a returned record via the key

async getAllFollows() {
let follows = await Follow.find({ isActive: true }).exec();
follows.map(follow => {
let amIStoryFollow = follow instanceof StoryFollow
console.log(${follow.followType}- ${amIStoryFollow}) // should be true when type='followStory'
})
}

[MDrooker]

@nodkz Are you seeing that behavior also?

[nodkz]

@MDrooker all that you need you may find in this improved test case:

graphql-compose-mongoose/src/__tests__/github-issues-test.js

Lines 45 to 97 in d2a2a18

	it('manually override resolver output type for findMany', async () => {
	const EventDescriminatorType = new graphql.GraphQLUnionType({
	name: 'EventDescriminator',
	types: [EventTC.getType(), ClickedLinkEventTC.getType()],
	resolveType: value => {
	if (value.kind === 'ClickedLinkEvent') {
	return ClickedLinkEventTC.getType();
	}
	return EventTC.getType();
	},
	});
	EventTC.getResolver('findMany').setType(new graphql.GraphQLList(EventDescriminatorType));
	// let's check graphql response
	await Event.create({ refId: 'aaa' });
	await Event.create({ refId: 'bbb' });
	await ClickedLinkEvent.create({ refId: 'ccc', url: 'url1' });
	await ClickedLinkEvent.create({ refId: 'ddd', url: 'url2' });
	GQC.rootQuery().addFields({
	eventFindMany: EventTC.getResolver('findMany'),
	});
	const schema = GQC.buildSchema();
	const res = await graphql.graphql(
	schema,
	`{
	eventFindMany {
	__typename
	... on GenericEvent {
	refId
	}
	... on ClickedLinkEvent {
	refId
	url
	}
	}
	}`
	);
	expect(res).toEqual({
	data: {
	eventFindMany: [
	{ __typename: 'GenericEvent', refId: 'aaa' },
	{ __typename: 'GenericEvent', refId: 'bbb' },
	{ __typename: 'ClickedLinkEvent', refId: 'ccc', url: 'url1' },
	{ __typename: 'ClickedLinkEvent', refId: 'ddd', url: 'url2' },
	],
	},
	});
	});

[sergio91pt]

@nodkz What if its in a sub-document, as an array?
eg.const sessionSchema = new mongoose.Schema({ 'generated': { 'events': [eventSchema] } })

Modifying TypeComposer.gqType to an union fixes the query but results in an error log when there's an attempt to convert the field to an input type (when inspecting the API through GraphQLi).

[mernxl]

hello, I have gone through the comments, but really i wanted more flexibility, so i have gone ahead to create a small library that uses graphql-compose-mongoose under the hud. It creates a typeComposer, and an interface for the baseModel, then the baseTypeComposer exposes a discriminator function that returns a typeComposer that implements the baseType Interface.

It exposes a single function, composeWithMongooseDiscriminator that returns a custom DiscriminatorTypeComposer that has the discriminator method to create ChildDiscriminatorTypeComposer. The child is a normal TypeComposer with the baseInterface set as interface.

LIVE DEMO. Edited to point to Graphql-compose-example app

@nodkz is it possible you integrate this with graphql-compose-mongoose or should i create a graphql-compose-mongoose-discriminators repo? Really love to hear from you with regards to this, haven't published yet.

[nodkz]

@mernxl I'm super excited by your work! 👍💪
This is a really good improvement for graphql-compose-mongoose.

Feel free to open PR.
Via series of commits, we add tests, examples and polish the code. Don't forget to allow me to make changes in your PR (there is a checkbox when you open PR).