How to register mongoose plugin for all schemas? - node.js

Question

What am I missing? The Mongoose docs say that mongoose.plugin() registers a plugin for all schemas. This is not working. I CAN register my plugin on EACH schema.
My plugin:
module.exports = function (schema, options) {
schema.set('toObject',{
transform: function (doc, ret, options) {
return {
test: 'It worked!'
};
}
});
};
My schema:
var testPlugin = require('test-plugin.js');
var personSchema = mongoose.Schema({
_id : { type: String, default: $.uuid.init },
ssn : { type: String, required: true, trim: true },
first : { type: String, required: true, trim: true },
middle : { type: String, required: true, trim: true },
last : { type: String, required: true, trim: true }
});
personSchema.plugin(testPlugin);
var model = mongoose.model('Person', personSchema);
module.exports = model;
The code above works, unfortunately. However, the following code does not:
var personSchema = mongoose.Schema({
_id : { type: String, default: $.uuid.init },
ssn : { type: String, required: true, trim: true },
first : { type: String, required: true, trim: true },
middle : { type: String, required: true, trim: true },
last : { type: String, required: true, trim: true }
});
var model = mongoose.model('Person', personSchema);
module.exports = model;
My test app:
var testPlugin = require('test-plugin.js');
mongoose.plugin(testPlugin);
mongoose.Promise = global.Promise;
mongoose.connect(config.db);
mongoose.connection.on('error', function (err) {
if (err) { throw err; }
});
mongoose.connection.once('open', function (err) {
if (err) { throw err; }
seeds.doSeed(function(err){
if (err) { return process.exit(1); }
models.Person.find({}, function(err, people){
if (err) { throw err; }
var person = people[0];
var oPerson = person.toObject();
console.log(JSON.stringify(oPerson));
});
});
});
I've tried moving the mongoose.plugin(testPlugin) all over the app.js file... after the connect, etc... and nothing has worked.

Answer 1

Plugins might not be registered with mongoose.plugin(myMongoosePlugin) because mongoose models were created before you are registering plugins globally.
In case if you have expressjs routes:
Make sure that in your app.js (server.js) you are registering mongoose plugins before you are registering/creating expressjs routes (which are using mongoose models to communicate with database).
Example:
in app.js
const express = require(express);
const mongoose = require('mongoose');
const myMongoosePlugin = require('<Mongoose Plugin file path>');
mongoose.plugin(myMongoosePlugin);
let app = express();
//register expressjs routes
require('<Express routes file path>')(app, express.Router());
// or create expressjs routes
app.post('/person', (req, res, next) => {
//where someMethod is using person mongoose model
this.someController.someMethod(someArguments)
.then((user) => {
res.json(user);
}).catch((error) => {
next(error);
});
});
// ... Some other code ...
mongoose.connect(<databaseConnectionString>);
app.listen(<Port>);

Answer 2

Try requiring your model also in your app.js file. Somewhere after mongoose.plugin(testPlugin).

Answer 3

This is not the best solution but work , you must define your Schema in each file and then export that
const mongoose = require('mongoose');
const UserSchema = new mongoose.Schema({ ... })
module.exports = UserSchema;
and then you should implement just one file for setup your models , for example
const mongoose = require('mongoose');
// import all of your schemas
const userSchema = require(./user/modelSchema);
const TicketSchema = require(./Ticket/modelSchema);
// *** implement your (Global Plugin) here ***
mongoose.plugin(myPlugin);
// define and create all of your models
const User = mongoose.model('User', userSchema);
const Ticket = mongoose.model('Ticket', TicketSchema);
module.exports = {
userModle: User,
ticketModel: Ticket,
}

Answer 4

This is just another view of what #Andrei Surzhan already stated.
The key here is to Apply the plugins before the Routes.
I recently got this issue, where the plugin's didn't work on a Global scale but it did when added them individually on the creation of their Schema.
For reference, my project is structured this way.
// server.js file
require('dotenv').config();
const http = require('http');
const mongoose = require('mongoose');
const myPlugin = require('path-to-my-plugin');
mongoose.plugin(myPlugin);
const app = require('./app');
const PORT = process.env.PORT || 8000;
const server = http.createServer(app);
// MONGO CONNECTION
mongoose.connect(process.env.MONGODB_URI);
mongoose.connection.on('open', () => console.log('MongoDB connection ready!'));
mongoose.connection.on('error', console.error);
server.listen(PORT, console.log(`Listening on PORT ${PORT}`));
// app.js file
const express = require('express');
// Routes
const clientsRouter = require('./routes/clients/clients.router');
const paymentsRouter = require('./routes/payments/payments.router');
const app = express();
// Parse incoming requests with JSON payloads
app.use(express.json());
// Parse incoming requests with Form payloads
app.use(
express.urlencoded({
extended: false,
})
);
app.use('/clients', clientsRouter);
app.use('/payments', paymentsRouter);
module.exports = app;
As you can see at server.js we add the plugin before even importing app.js this is because when we import app.js we will call the routes and the plugin will not be passed.
Another way to do it, is adding the plugin on each Schema.
Example
// clients.model.js
const mongoose = require('mongoose');
const myPlugin = require('path-to-my-plugin');
const clientSchema = new mongoose.Schema({ ... });
clientSchema.plugin(myPlugin);
module.exports = mongoose.model('Client', clientSchema);