Looking for a way to manipulate some fields in mongoose(likely how middleware works) but without having to resort to any backend code

Thanks for your valuable attention, I'm working on MERN stack & trying to do something that's not working like I am expecting it to be.(Sorry if this turns out to be a repeated question, I'm new to web dev).

Here Goes

1.) There is this 'Lead' schema that contains many fields, one particular being 'status', when status is changed from 'stageX' to 'stageY' for a Lead, I want that particular document to update a field 'stageYdate'(initially null) with the current Date.

2.) I want this to happen regardless of previous existing routes and requests, the field should update depending upon the 'status' field, so a model level middleware(not sure if it should be document level instead)

3.) Tried performing operation on a mock schema/model and it isn't working either.

Making schema and exporting model

const mongoose = require("mongoose");
const Schema = mongoose.Schema;

const ModelMiddlewareSchema = new mongoose.Schema({
  stage: {
    type: String
  },
  stageChangeDate:{
    type: Date,
  }
});
const ModelMiddleware = mongoose.model('ModelMiddleware', ModelMiddlewareSchema);
//Tried using middleware here on "ModelMiddleware", didn't work :(
module.exports = ModelMiddleware; 

It was giving error that ModelMiddleware.pre() function is not defined so i had to use it in routes

const ModelMiddleware = require('../models/modelMiddlewareCheck');
const express = require('express');
const router = express.Router();

const logMiddleware = async function(next) {
  console.log(`Saving document ${this._id}`);
  this.stage = 'stage2'
  next();
};

ModelMiddleware.schema.pre('save', logMiddleware);

router.put('/', async (req, res) => {
  try {
    console.log('req received as', req.body);
    const newDoc = new ModelMiddleware();
    newDoc.stage = 'stage1';
    await newDoc.save();
    return res.status(200).send('stage1 created successfully');
  } catch (err) {
    console.log(err);
    res.status(400).send('unsuccessful operation');
  }
});

module.exports = router;

Above was mock but i want to do something like this

const stage_initial = this.stage;

const postStageCheck = function(next){
const stage_final = this.stage;
if(stage_initial==='stage1' && stage_final==='stage2'){
    this.stageChangeDate = new Date();
    this.save()
 }
next();
}
ModelMiddleware.post('save', postStageCheck)

This worked in adding date field by monitoring stage change in mongo

const mongoose = require("mongoose");
const ModelMiddlewareSchema = new mongoose.Schema({
stage: {
type: String
},
stageChangeDate: {
type: Date
}
});
ModelMiddlewareSchema.pre('update', function(next) {
console.log('pre middleware is fired update')
const currentStatus = this.stage
if(this.isModified('stage')) {
const newStatus = this.status
if (currentStatus === 'stage1' && newStatus === 'stage2') {
this.stageChangeDate = new Date()
console.log('new date is added')
}
}
next();
});
ModelMiddlewareSchema.pre('save', function(next) {
console.log('pre middleware is fired save')
const currentStatus = this.stage
if(this.isModified('stage')) {
const newStatus = this.status
if (currentStatus === 'stage1' && newStatus === 'stage2') {
this.stageChangeDate = new Date()
console.log('new date is added')
}
}
next();
});
ModelMiddlewareSchema.pre('findOneAndUpdate', async function(next) {
console.log('pre middleware is fired findOneAndUpdate')
const update = this.getUpdate(); // Access the update object
console.log('update is ', update)
if (update && update['$set'].stage) {
const document = await this.findOne();
const project =await projects.findOne();
console.log('document is ', document)
const currentStatus = document.stage;
const updatedStatus = update['$set'].stage;
console.log('currentStatus is ', currentStatus)
console.log('updatedStatus is ', updatedStatus)
if (currentStatus === 'stage1' && updatedStatus === 'stage2') {
update.$set.stageChangeDate = new Date();
console.log('update after adding date is ', update)
}
}
next();
});
const ModelMiddleware = mongoose.model('ModelMiddleware', ModelMiddlewareSchema);
module.exports = ModelMiddleware;

The usage of a model middleware is the way to go to permform the check regardless of where the update is coming from.

However, I would use pre instead of post, then you can bundle the stageChangeDate update together with the new status update which would reduce the number of requests to the database.

const schema = new Schema({ /* ... */ });
schema.pre('save', function(next) {
const currentStatus = this.status
if (this.isModified('status') {
const newStatus = this.status
if (currentStatus === 'x' && newStatus === 'y') {
this.stageChangeDate = new Date()
}
}
next();
});

Overall on the right track but needs a few changes.

You want to modify the document before it's saved so use pre middleware instead of post. post is executed after the document has been saved so it's too late to make changes.

You need to manually store the previous state if you want to compare it to the new state. You can do this by using a combination of pre and post.

// Pre-save middleware to store the stage
ModelMiddlewareSchema.pre('save', function(next) {
// Store the initial stage on the document
this._initialStage = this.stage;
next();
});
// Post-save middleware to check for change and update
ModelMiddlewareSchema.post('save', async function(doc) {
if (this._initialStage === 'stage1' && this.stage === 'stage2') {
// Update the stageChangeDate field
this.stageChangeDate = new Date();
// Save the updated document
await this.save();
}
});

You can use virtual properties, getters, and setters in your schema definition to modify fields in a Mongoose schema without using backend code. These enable you to create unique access and value definition logic for fields in your documents.

Virtual properties are those of a document that are computed on-the-fly using data from other fields but are not stored in the database. Using the 'virtual' method, you can define virtual properties in your Mongoose schema.

Here is an illustration of how to change fields in Mongoose using virtual properties:

<!-- language: lang-js -->

const mongoose = require('mongoose');
const userSchema = new mongoose.Schema({
firstName: String,
lastName: String
});
// Define a virtual property for the full name
userSchema.virtual('fullName').get(function() {
return `${this.firstName} ${this.lastName}`;
}).set(function(fullName) {
const [firstName, lastName] = fullName.split(' ');
this.firstName = firstName;
this.lastName = lastName;
});
const User = mongoose.model('User', userSchema);
// Create a new user
const user = new User({ firstName: 'John', lastName: 'Doe' });
console.log(user.fullName); // Output: "John Doe"
user.fullName = 'Jane Smith';
console.log(user.firstName); // Output: "Jane"
console.log(user.lastName); // Output: "Smith"

<!-- end snippet -->

In the aforementioned example, the fields firstName and lastName are combined into a virtual property called fullName. When fullName is being retrieved, the get function is used, and when it is being set, the set function is used.

Putters and Takers
Alternately, you can directly alter fields in your Mongoose schema by using getters and setters. You can create your own logic for field access and setting by using getters and setters.

Here is an illustration of how Mongoose uses getters and setters:

<!-- language: lang-js -->

const mongoose = require('mongoose');
const userSchema = new mongoose.Schema({
firstName: String,
lastName: String
});
// Define a getter and setter for the full name
userSchema.path('firstName').get(function(value) {
return value.charAt(0).toUpperCase() + value.slice(1);
}).set(function(value) {
return value.trim();
});
const User = mongoose.model('User', userSchema);
// Create a new user
const user = new User({ firstName: '  john', lastName: 'doe  ' });
console.log(user.firstName); // Output: "John"
user.firstName = '  jane  ';
console.log(user.firstName); // Output: "Jane"

<!-- end snippet -->

For the firstName field, we define a getter and setter in this example. The setter removes any leading or following whitespace from the firstName value and the getter capitalizes the first character of the value.

Both virtual properties and getters/setters give Mongoose users the ability to edit fields without actually changing the backend logic. Based on the particular demands of your application, select the strategy that best meets your needs.