Mongoose Schema builder for ES6 classes that supports multilevel inheritance.
MIT License
SchematicClass is a way to build your mongoose schemas and models using native classes. Additionally, SchematicClass extends mongoose's native discriminators to support multilevel discriminators (inheritance).
npm
npm install --save mongo-schematic-class
yarn
yarn add mongo-schematic-class
const { createModel } = require('mongo-schematic-class');
class Vehicle {
// Define the structure of the Schema.
static get __context() {
return {
vin: {
type: String,
required: true,
unique: true,
},
milesTraveled: {
type: Number,
default: 0,
}
};
}
// This instance method will be added to the Schema and be inherited by all subclasses.
drive(miles) {
this.milesTraveled += miles;
}
}
// Create the Vehicle model.
createModel(Vehicle);
class GasVehicle extends Vehicle {
// Define the structure of the Schema.
static get __context() {
return {
tankSize: {
type: Number,
required: true,
},
mpg: {
type: Number,
required: true,
},
}
}
// Define the virtuals that should be added to the Schema. These are not suggested,
// but supported for backwards compatibility.
static get __virtuals() {
return {
drivingRange: {
get: function getDrivingRange() {
return (this.tankSize * this.mpg);
},
},
};
}
// If you define a virtual on the Schema, you should define a similar one on the class.
get drivingRange() {
return (this.tankSize * this.mpg);
}
}
// Create the GasVehicle model.
createModel(GasVehicle);
createModel(Class: SchematicClass, modelName?: string): Model
Creates a Model for the specified SchematicClass. This is the only method that has to be called on the SchematicClass.
Type | Description |
---|---|
SchematicClass |
The SchematicClass for which the Model should be created. |
string |
Optional. The name of the Model. If omitted, the name of the SchematicClass is used. |
SchematicClass works by looking at static properties on the provided class to build the mongoose schema. The following properties are supported:
Name | Type | Required | Description |
---|---|---|---|
__context |
{ [ propertyName: string ]: any } |
true |
This is effectively the schema for your class. You'll define all of the instance properties on your class as well as their type. Any mongoose supported type is supported. |
__pre |
{ [ eventName: string ]: (...args: any[]) => any } |
false |
The prehooks to define on the schema. |
__post |
{ [ eventName: string ]: (...args: any[]) => any } |
false |
The posthooks to define on the schema. |
__virtuals |
{ [ virtualName: string ]: { get?: () => any, set?: (val: any) => void } } |
false |
The virtuals to define for this class. Virtuals are generally discouraged when using SchematicClass as it requires duplication of code (you must define a getter and setter twice, once for the Model and once for the class). Instead, you can use an instance method to get a similar effect. |
__foreignKeys |
{ [ foreignKeyName: string ]: { ref: string | Model, localField: string | (() => string), foreignField: string | (() => string), justOne?: boolean, count?: boolean } } | false |
Foreign keys to define on the schema. Foreign keys in mongoose can be used to populate documents based on values other than the _id field. See the mongoose documentation for further information. |
__queryHelpers |
{ [ queryName: string ]: (this: Model, ...args: any[]) => DocumentQuery } |
false |
Defines a mongoose query helper on the schema. |
One of the main benefits of mongo-schematic-class is the support for multilevel discriminators (inheritance). The following properties defined on a SchematicClass are inheritable:
__context
)__pre
& __post
)__virtuals
)__foreignKeys
)__queryHelpers
)*Unlike other inheritable properties, middleware cannot be overridden. If you define a pre hook on your superclass and the same pre hook on the subclass, both pre hooks will be executed.
While building the schema and creating the model, mongo-schematic-class will add the following static properties to your SchematicClass.
__schema
- This is the schema generated when you execute buildSchema()
or createModel()
__model
- This is the model created when you execute createModel()
__inherits
- This is the SchematicClass's parent class. This is added when you call inherits()
or createModel()
.isInstanceOf()
- This is a helper method that should be used in place of the instanceof
operator when trying to determine if an object is an instance of a SchematicClass. This works for both instances of the Model and instances of the actual SchematicClass. isInstanceOf()
will follow the inheritance chain.buildSchema(Class: SchematicClass)
Builds the Mongoose schema as configured on the SchematicClass. After running this, the __schema
property will be added to Class
.
Type | Description |
---|---|
SchematicClass |
The SchematicClass for which a schema should be built. |
Type | Description |
---|---|
Model |
The model created for Class. |
inherits(Subclass: SchematicClass, Superclass: SchematicClass)
Instructs mongo-schematic-class that Subclass inherits from Superclass. Both Subclass and Superclass must be a SchematicClass. If this method is not called when inheriting a Superclass, buildSchema()
will automatically detect that Subclass inherits from Superclass and call this method.
After calling this, the __inherits
property will be added to Subclass
.
Type | Description |
---|---|
SchematicClass |
The subclass inheriting from Superclass |
SchematicClass |
The superclass from which subclass inherits. |