MongooseError: Model.findOne() no longer accepts a callback && userSchema.plugin(autoIncrement.plugin, 'user');

Question

import mongoose from "mongoose";
import autoIncrement from "mongoose-auto-increment";

const userSchema = mongoose.Schema({
    name: String,
    username: String,
    email: String,
    phone: String
})

autoIncrement.initialize(mongoose.connection);
userSchema.plugin(autoIncrement.plugin, 'user'); //error occurs in this line, when I comment this line, rest work fine.

const user = mongoose.model('user', userSchema);

export default user;

In the given code, when I comment the line number 12 which is as follow. userSchema.plugin(autoIncrement.plugin, 'user');
Then it work fine but when I try to go with `userSchema.plugin(autoIncrement.plugin, 'user');`.\ It gives the error which can clearly be seen in the screenshot under terminal section.

Error message is as follow.

MongooseError: Model.findOne() no longer accepts a callback
    at Function.findOne (D:\personal project\rough\CRUD\server\node_modules\mongoose\lib\model.js:2129:11)
    at exports.plugin (D:\personal project\rough\CRUD\server\node_modules\mongoose-auto-increment\index.js:73:19)      
    at Schema.plugin (D:\personal project\rough\CRUD\server\node_modules\mongoose\lib\schema.js:1884:3)
    at file:///D:/personal%20project/rough/CRUD/server/schema/user-schema.js:12:12
    at ModuleJob.run (node:internal/modules/esm/module_job:194:25)

Node.js v19.1.0
[nodemon] app crashed - waiting for file changes before starting...

1. I uninstalled and reinstalled the mongoose-auto-increment.
2. I have check this Function.findOne (node_modules\mongoose\lib\model.js:2129:11) but not find anything which I need to modify.

Answer 1

I have the same problem when migrate old project to mongodb 6.0.

There are more problem with it Model.prototype.save() no longer accepts a callback.

I just make my project run, not assure the function right.

I have find the origin repo here.

The Line 73 used the findOne function. I think that's the problem. But the lib was no longer maintained. Maybe we should change to other libs or import the code and fix it.

I am import it to local file and fix it.

1. remove the dependency in package.json

"mongoose-auto-increment": "^5.0.1",

add dependency.

"extend": "^3.0.0",

2. copy the code and fix it. create file: mongoose-auto-increment.js.

// Module Scope
var mongoose = require('mongoose'),
    extend = require('extend'),
    counterSchema,
    IdentityCounter;

// Initialize plugin by creating counter collection in database.
exports.initialize = function (connection) {
    try {
        IdentityCounter = connection.model('IdentityCounter');
    } catch (ex) {
        if (ex.name === 'MissingSchemaError') {
            // Create new counter schema.
            counterSchema = new mongoose.Schema({
                model: { type: String, require: true },
                field: { type: String, require: true },
                count: { type: Number, default: 0 }
            });

            // Create a unique index using the "field" and "model" fields.
            counterSchema.index({ field: 1, model: 1 }, { unique: true, required: true, index: -1 });

            // Create model using new schema.
            IdentityCounter = connection.model('IdentityCounter', counterSchema);
        }
        else
            throw ex;
    }
};

// The function to use when invoking the plugin on a custom schema.
exports.plugin = function (schema, options) {

    // If we don't have reference to the counterSchema or the IdentityCounter model then the plugin was most likely not
    // initialized properly so throw an error.
    if (!counterSchema || !IdentityCounter) throw new Error("mongoose-auto-increment has not been initialized");

    // Default settings and plugin scope variables.
    var settings = {
        model: null, // The model to configure the plugin for.
        field: '_id', // The field the plugin should track.
        startAt: 0, // The number the count should start at.
        incrementBy: 1, // The number by which to increment the count each time.
        unique: true // Should we create a unique index for the field
    },
        fields = {}, // A hash of fields to add properties to in Mongoose.
        ready = false; // True if the counter collection has been updated and the document is ready to be saved.

    switch (typeof (options)) {
        // If string, the user chose to pass in just the model name.
        case 'string':
            settings.model = options;
            break;
        // If object, the user passed in a hash of options.
        case 'object':
            extend(settings, options);
            break;
    }

    if (settings.model == null)
        throw new Error("model must be set");

    // Add properties for field in schema.
    fields[settings.field] = {
        type: Number,
        require: true
    };
    if (settings.field !== '_id')
        fields[settings.field].unique = settings.unique
    schema.add(fields);

    // Find the counter for this model and the relevant field.
    IdentityCounter.findOne(
        { model: settings.model, field: settings.field })
        .then(counter => {
            if (!counter) {
                // If no counter exists then create one and save it.
                counter = new IdentityCounter({ model: settings.model, field: settings.field, count: settings.startAt - settings.incrementBy });
                counter.save()
                    .then(() => {
                        ready = true;
                    });
            }
            else {
                ready = true;
            }
        })
        .catch(err => {
            // TODO
        });

    // Declare a function to get the next counter for the model/schema.
    var nextCount = function (callback) {
        IdentityCounter.findOne({
            model: settings.model,
            field: settings.field
        })
            .then((counter) => {
                callback(null, counter === null ? settings.startAt : counter.count + settings.incrementBy);
            })
            .catch(err => {
                callback(err);
            })
    };
    // Add nextCount as both a method on documents and a static on the schema for convenience.
    schema.method('nextCount', nextCount);
    schema.static('nextCount', nextCount);

    // Declare a function to reset counter at the start value - increment value.
    var resetCount = function (callback) {
        IdentityCounter.findOneAndUpdate(
            { model: settings.model, field: settings.field },
            { count: settings.startAt - settings.incrementBy },
            { new: true }, // new: true specifies that the callback should get the updated counter.
        )
            .then(() => {
                callback(null, settings.startAt);
            })
            .catch(err => {
                callback(err);
            });
    };
    // Add resetCount as both a method on documents and a static on the schema for convenience.
    schema.method('resetCount', resetCount);
    schema.static('resetCount', resetCount);

    // Every time documents in this schema are saved, run this logic.
    schema.pre('save', function (next) {
        // Get reference to the document being saved.
        var doc = this;

        // Only do this if it is a new document (see http://mongoosejs.com/docs/api.html#document_Document-isNew)
        if (doc.isNew) {
            // Declare self-invoking save function.
            (function save() {
                // If ready, run increment logic.
                // Note: ready is true when an existing counter collection is found or after it is created for the
                // first time.
                if (ready) {
                    // check that a number has already been provided, and update the counter to that number if it is
                    // greater than the current count
                    if (typeof doc[settings.field] === 'number') {
                        IdentityCounter.findOneAndUpdate(
                            // IdentityCounter documents are identified by the model and field that the plugin was invoked for.
                            // Check also that count is less than field value.
                            { model: settings.model, field: settings.field, count: { $lt: doc[settings.field] } },
                            // Change the count of the value found to the new field value.
                            { count: doc[settings.field] },
                        )
                            .then((err) => {
                                // Continue with default document save functionality.
                                next();
                            })
                            .catch(err => {
                                return next(err);
                            });
                    } else {
                        // Find the counter collection entry for this model and field and update it.
                        IdentityCounter.findOneAndUpdate(
                            // IdentityCounter documents are identified by the model and field that the plugin was invoked for.
                            { model: settings.model, field: settings.field },
                            // Increment the count by `incrementBy`.
                            { $inc: { count: settings.incrementBy } },
                            // new:true specifies that the callback should get the counter AFTER it is updated (incremented).
                            { new: true },
                            // Receive the updated counter.
                        )
                        .then((err, updatedIdentityCounter) => {
                            // If there are no errors then go ahead and set the document's field to the current count.
                            doc[settings.field] = updatedIdentityCounter.count;
                            // Continue with default document save functionality.
                            next();
                        })
                        .catch(err => {
                            return next(err);
                        })
                    }
                }
                // If not ready then set a 5 millisecond timer and try to save again. It will keep doing this until
                // the counter collection is ready.
                else
                    setTimeout(save, 5);
            })();
        }
        // If the document does not have the field we're interested in or that field isn't a number AND the user did
        // not specify that we should increment on updates, then just continue the save without any increment logic.
        else
            next();
    });
};

3. modify all the require(), depends on the mongoose-auto-increment.js location.

require('../util/mongoose-auto-increment.js');

That's all.

Answer 2

I have used custom auto-increment logic and hope it will help you.

import mongoose from "mongoose";

const counterSchema = mongoose.Schema({
  _id: { type: String, required: true },
  seq: { type: Number, default: 0 }
});

const Counter = mongoose.model('Counter', counterSchema);

const userSchema = mongoose.Schema({
  userId: { type: Number, unique: true },
  name: String,
  username: String,
  email: String,
  phone: String
});

userSchema.pre('save', function (next) {
  const doc = this;
  Counter.findByIdAndUpdate({ _id: 'userId' }, { $inc: { seq: 1 } }, { new: true, upsert: true })
    .then(function (counter) {
      doc.userId = counter.seq;
      next();
    })
    .catch(function (error) {
      return next(error);
    });
});

const user = mongoose.model('user', userSchema);

export default user;