The model.discriminator() function

    Discriminators are a schema inheritance mechanism. They enable you to have multiple models with overlapping schemas on top of the same underlying MongoDB collection.

    Suppose you wanted to track different types of events in a single collection. Every event will have a timestamp, but events that represent clicked links should have a URL. You can achieve this using the model.discriminator() function. This function takes 2 parameters, a model name and a discriminator schema. It returns a model whose schema is the union of the base schema and the discriminator schema.

    2.     var options = {discriminatorKey: 'kind'};
    4.     var eventSchema = new mongoose.Schema({time: Date}, options);
    5.     var Event = mongoose.model('Event', eventSchema);
    7.     // ClickedLinkEvent is a special type of Event that has
    8.     // a URL.
    9.     var ClickedLinkEvent = Event.discriminator('ClickedLink',
    10.       new mongoose.Schema({url: String}, options));
    12.     // When you create a generic event, it can't have a URL field...
    13.     var genericEvent = new Event({time: Date.now(), url: 'google.com'});
    14.     assert.ok(!genericEvent.url);
    16.     // But a ClickedLinkEvent can
    17.     var clickedEvent =
    18.       new ClickedLinkEvent({time: Date.now(), url: 'google.com'});
    19.     assert.ok(clickedEvent.url);

    Discriminators save to the Event model’s collection

    Suppose you created another discriminator to track events where a new user registered. These SignedUpEvent instances will be stored in the same collection as generic events and ClickedLinkEvent instances.

    2.     var event1 = new Event({time: Date.now()});
    3.     var event2 = new ClickedLinkEvent({time: Date.now(), url: 'google.com'});
    4.     var event3 = new SignedUpEvent({time: Date.now(), user: 'testuser'});
    6.     var save = function (doc, callback) {
    7.       doc.save(function (error, doc) {
    8.         callback(error, doc);
    9.       });
    10.     };
    12.     async.map([event1, event2, event3], save, function (error) {
    14.       Event.count({}, function (error, count) {
    15.         assert.equal(count, 3);
    16.       });
    17.     });

    Discriminator keys

    The way mongoose tells the difference between the different discriminator models is by the ‘discriminator key’, which is __t by default. Mongoose adds a String path called __t to your schemas that it uses to track which discriminator this document is an instance of.

    2.     var event1 = new Event({time: Date.now()});
    3.     var event2 = new ClickedLinkEvent({time: Date.now(), url: 'google.com'});
    4.     var event3 = new SignedUpEvent({time: Date.now(), user: 'testuser'});
    6.     assert.ok(!event1.__t);
    7.     assert.equal(event2.__t, 'ClickedLink');
    8.     assert.equal(event3.__t, 'SignedUp');

    Discriminators add the discriminator key to queries

    Discriminator models are special; they attach the discriminator key to queries. In other words, find(), count(), aggregate(), etc. are smart enough to account for discriminators.

    2.     var event1 = new Event({time: Date.now()});
    3.     var event2 = new ClickedLinkEvent({time: Date.now(), url: 'google.com'});
    4.     var event3 = new SignedUpEvent({time: Date.now(), user: 'testuser'});
    6.     var save = function (doc, callback) {
    7.       doc.save(function (error, doc) {
    8.         callback(error, doc);
    9.       });
    10.     };
    12.     async.map([event1, event2, event3], save, function (error) {
    14.       ClickedLinkEvent.find({}, function (error, docs) {
    15.         assert.equal(docs.length, 1);
    16.         assert.equal(docs[0]._id.toString(), event2._id.toString());
    17.         assert.equal(docs[0].url, 'google.com');
    18.       });
    19.     });

    Discriminators copy pre and post hooks

    Discriminators also take their base schema’s pre and post middleware. However, you can also attach middleware to the discriminator schema without affecting the base schema.

    2.     var options = {discriminatorKey: 'kind'};
    4.     var eventSchema = new mongoose.Schema({time: Date}, options);
    5.     var eventSchemaCalls = 0;
    6.     eventSchema.pre('validate', function (next) {
    7.       ++eventSchemaCalls;
    8.       next();
    9.     });
    10.     var Event = mongoose.model('GenericEvent', eventSchema);
    12.     var clickedLinkSchema = new mongoose.Schema({url: String}, options);
    13.     var clickedSchemaCalls = 0;
    14.     clickedLinkSchema.pre('validate', function (next) {
    15.       ++clickedSchemaCalls;
    16.       next();
    17.     });
    18.     var ClickedLinkEvent = Event.discriminator('ClickedLinkEvent',
    19.       clickedLinkSchema);
    21.     var event1 = new ClickedLinkEvent();
    22.     event1.validate(function() {
    23.       assert.equal(eventSchemaCalls, 1);
    24.       assert.equal(clickedSchemaCalls, 1);
    26.       var generic = new Event();
    27.       generic.validate(function() {
    28.         assert.equal(eventSchemaCalls, 2);
    29.         assert.equal(clickedSchemaCalls, 1);
    30.       });
    31.     });

    Handling custom _id fields

    A discriminator’s fields are the union of the base schema’s fields and the discriminator schema’s fields, and the discriminator schema’s fields take precedence. There is one exception: the default _id field.

    You can work around this by setting the _id option to false in the discriminator schema as shown below.

    2.     var options = {discriminatorKey: 'kind'};
    4.     // Base schema has a String `_id` and a Date `time`...
    5.     var eventSchema = new mongoose.Schema({_id: String, time: Date},
    6.       options);
    7.     var Event = mongoose.model('BaseEvent', eventSchema);
    9.     var clickedLinkSchema = new mongoose.Schema({
    10.       url: String,
    11.       time: String
    12.     }, options);
    13.     // But the discriminator schema has a String `time`, and an implicitly added
    14.     // ObjectId `_id`.
    15.     assert.ok(clickedLinkSchema.path('_id'));
    16.     assert.equal(clickedLinkSchema.path('_id').instance, 'ObjectID');
    17.     var ClickedLinkEvent = Event.discriminator('ChildEventBad',
    18.       clickedLinkSchema);
    20.     var event1 = new ClickedLinkEvent({ _id: 'custom id', time: '4pm' });
    21.     // Woops, clickedLinkSchema overwrites the `time` path, but **not**
    22.     // the `_id` path because that was implicitly added.
    23.     assert.ok(typeof event1._id === 'string');
    24.     assert.ok(typeof event1.time === 'string');

    Using discriminators with Model.create()

    When you use Model.create(), mongoose will pull the correct type from the discriminator key for you.

    2.     var Schema = mongoose.Schema;
    3.     var shapeSchema = new Schema({
    4.       name: String
    5.     }, { discriminatorKey: 'kind' });
    7.     var Shape = db.model('Shape', shapeSchema);
    9.     var Circle = Shape.discriminator('Circle',
    10.       new Schema({ radius: Number }));
    11.     var Square = Shape.discriminator('Square',
    12.       new Schema({ side: Number }));
    14.     var shapes = [
    15.       { name: 'Test' },
    16.       { kind: 'Circle', radius: 5 },
    17.       { kind: 'Square', side: 10 }
    18.     ];
    19.     Shape.create(shapes, function(error, shapes) {
    20.       assert.ifError(error);
    21.       assert.ok(shapes[0] instanceof Shape);
    22.       assert.ok(shapes[1] instanceof Circle);
    23.       assert.equal(shapes[1].radius, 5);
    24.       assert.ok(shapes[2] instanceof Square);
    25.       assert.equal(shapes[2].side, 10);
    26.     });

    Embedded discriminators in arrays

    You can also define discriminators on embedded document arrays. Embedded discriminators are different because the different discriminator types are stored in the same document array (within a document) rather than the same collection. In other words, embedded discriminators let you store subdocuments matching different schemas in the same array.

    As a general best practice, make sure you declare any hooks on your schemas before you use them. You should not call pre() or post() after calling discriminator()

    2.     var eventSchema = new Schema({ message: String },
    3.       { discriminatorKey: 'kind', _id: false });
    5.     var batchSchema = new Schema({ events: [eventSchema] });
    7.     // `batchSchema.path('events')` gets the mongoose `DocumentArray`
    8.     var docArray = batchSchema.path('events');
    10.     // The `events` array can contain 2 different types of events, a
    11.     // 'clicked' event that requires an element id that was clicked...
    12.     var clickedSchema = new Schema({
    13.       element: {
    14.         type: String,
    15.         required: true
    16.       }
    17.     }, { _id: false });
    18.     // Make sure to attach any hooks to `eventSchema` and `clickedSchema`
    19.     // **before** calling `discriminator()`.
    20.     var Clicked = docArray.discriminator('Clicked', clickedSchema);
    22.     // ... and a 'purchased' event that requires the product that was purchased.
    23.     var Purchased = docArray.discriminator('Purchased', new Schema({
    24.       product: {
    25.         type: String,
    26.         required: true
    27.       }
    28.     }, { _id: false }));
    30.     var Batch = db.model('EventBatch', batchSchema);
    32.     // Create a new batch of events with different kinds
    33.     var batch = {
    34.       events: [
    35.         { kind: 'Clicked', element: '#hero', message: 'hello' },
    36.         { kind: 'Purchased', product: 'action-figure-1', message: 'world' }
    37.       ]
    38.     };
    40.     Batch.create(batch).
    41.       then(function(doc) {
    42.         assert.equal(doc.events.length, 2);
    44.         assert.equal(doc.events[0].element, '#hero');
    45.         assert.equal(doc.events[0].message, 'hello');
    46.         assert.ok(doc.events[0] instanceof Clicked);
    48.         assert.equal(doc.events[1].product, 'action-figure-1');
    49.         assert.equal(doc.events[1].message, 'world');
    50.         assert.ok(doc.events[1] instanceof Purchased);
    52.         doc.events.push({ kind: 'Purchased', product: 'action-figure-2' });
    53.         return doc.save();
    54.       }).
    55.       then(function(doc) {
    56.         assert.equal(doc.events.length, 3);
    58.         assert.equal(doc.events[2].product, 'action-figure-2');
    59.         assert.ok(doc.events[2] instanceof Purchased);
    61.         done();
    62.       }).
    63.       catch(done);

    Recursive embedded discriminators in arrays

    Recursive embedded discriminators

    2.     var singleEventSchema = new Schema({ message: String },
    3.       { discriminatorKey: 'kind', _id: false });
    5.     var eventListSchema = new Schema({ events: [singleEventSchema] });
    7.     var subEventSchema = new Schema({
    8.        sub_events: [singleEventSchema]
    9.     }, { _id: false });
    11.     var SubEvent = subEventSchema.path('sub_events').discriminator('SubEvent', subEventSchema)
    12.     eventListSchema.path('events').discriminator('SubEvent', subEventSchema);
    14.     var Eventlist = db.model('EventList', eventListSchema);
    16.     // Create a new batch of events with different kinds
    17.     var list = {
    18.       events: [
    19.         { kind: 'SubEvent', sub_events: [{kind:'SubEvent', sub_events:[], message:'test1'}], message: 'hello' },
    20.         { kind: 'SubEvent', sub_events: [{kind:'SubEvent', sub_events:[{kind:'SubEvent', sub_events:[], message:'test3'}], message:'test2'}], message: 'world' }
    21.       ]
    22.     };
    24.     Eventlist.create(list).
    25.       then(function(doc) {
    26.         assert.equal(doc.events.length, 2);
    28.         assert.equal(doc.events[0].sub_events[0].message, 'test1');
    29.         assert.equal(doc.events[0].message, 'hello');
    30.         assert.ok(doc.events[0].sub_events[0] instanceof SubEvent);
    32.         assert.equal(doc.events[1].sub_events[0].sub_events[0].message, 'test3');
    33.         assert.equal(doc.events[1].message, 'world');
    34.         assert.ok(doc.events[1].sub_events[0].sub_events[0] instanceof SubEvent);
    36.         doc.events.push({kind:'SubEvent', sub_events:[{kind:'SubEvent', sub_events:[], message:'test4'}], message:'pushed'});
    37.         return doc.save();
    38.       }).
    39.       then(function(doc) {
    40.         assert.equal(doc.events.length, 3);
    42.         assert.equal(doc.events[2].message, 'pushed');
    43.         assert.ok(doc.events[2].sub_events[0] instanceof SubEvent);
    45.         done();
    46.       }).
    47.       catch(done);