Mongoose & serverless offline "Cannot overwrite model once compiled."

[kalote]

Hello,

When using mongoose + mongodb + serverless offline, cannot make 2 calls in a row => the second one will not work & will exit with error:
'MongooseError: Cannot overwrite User model once compiled.'

Step to reproduce:

• git clone git@github.com:serverless/examples.git
• cd aws-node-rest-api-mongodb
• add the serverless-offline plugin + npm install
• start local mongodb & update handler.js with mongodb connection string
• sls offline start

Error:

• First call create user
  curl -XPOST -H "Content-type: application/json" -d '{"name":"name","firstname":"fname","birth":"01/01/1990","city":"Paris"}' 'http://localhost:3000/user'
• then call get user
  curl -XGET -H "Content-type: application/json" 'http://localhost:3000/user/USER_ID'
• error Cannot overwrite User model once compiled

Expected result:

• second and following call to offline api should work fine

Additional information:

• node version 7.10
• npm version 5.0.3
• serverless version 1.15.3

Any idea why the provided example doesn't work with offline ?

Thanks

[weiner]

Hello,

I run in the same problem.
Using the cli parameter --skipCacheInvalidation fixt it for me.

--skipCacheInvalidation -c Tells the plugin to skip require cache invalidation. A script reloading tool like Nodemon might then be needed.

[majoraze]

I'm using a microservice architecture, so my model are in multiple files and services like:
get.js
create.js

They are multiple handlers referencing the same model.

After I put the --skipCacheInvalidation -c flag it stopped doing this error when I call 2 times in a row the get.js service, but when I change and call the create.js after the get.js was called I get the same error as before.

Anyone?

[gokul-t]

you are compiling user schema multiple times, the reason is you call mongoose.model('User', UserSchema) in the first request and then in the second call too.

[majoraze]

I know that, but with the microservice architecture this is expected right? I have a require of my model in each service I use that model.

[gokul-t]

what about this?
global.UserSchema = global.UserSchema || mongoose.model('User', UserSchema);
module.exports = global.UserSchema;

[adrianovalente]

Hey guys! I got a nice hack to avoid this problem using the mongoose method to get an already declared model:

if (!modelAlreadyDeclared()) {
  const Users = mongoose.model('Users', yourSchema)
}

function modelAreadyDeclared () {
  try {
    mongoose.model('Users')  // it throws an error if the model is still not defined
    return true
  } catch (e) {
    return false
  }
}

[zhenyulin]

manage to resolve this problem via the following snippet, which restrict the behaviour in local offline environment as well as doesn't stop hot reload of models

if (process.env.IS_OFFLINE) {
	delete mongoose.connection.models.Item;
}

export default mongoose.model('Item', Item);

[harunsmrkovic]

It is also possible to circumvent this issue by using the new --useSeparateProcesses flag

[pedro-mass]

@harunsmrkovic Just tack on --useSeparateProcesses no further config?

I read that it kicks off a separate process for each function, but I'm still getting the OverwriteModelError: Cannot overwrite error

[PabloEzequiel]

Hello @adrianovalente, there is a misspelling in your code:
modelAlreadyDeclared != modelAreadyDeclared

so:

if (! modelAlreadyDeclared()) {
  const Users = mongoose.model('Users', yourSchema)
}

function modelAlreadyDeclared() {
  try {
    mongoose.model('Users')  // it throws an error if the model is still not defined
    return true
  } catch (e) {
    return false
  }
}

[PabloEzequiel]

The solution for me was the following code:

let Dataset = mongoose.models.Dataset || mongoose.model('Dataset', DatasetSchema);
Also, in mocha test:

//After all tests are finished:
after(() => {
        mongoose.models = {};
        mongoose.modelSchemas = {};
 });

After read a comment from:
https://github.com/cklanac/bellyful-api

that is a resume from:
Automattic/mongoose#1251

but, in deed, it suggest for mocha:

  after(function() {
     return mongoose.disconnect(() => {
       mongoose.models = {};
       mongoose.modelSchemas = {};
       mongoose.connection.close();
     });
  });

I hope this help ...

[michael-lowe-nz]

I had this problem.
Using the --skipCacheInvalidation flag worked, but this doesn't allow the server to reload on change.
So as per @harunsmrkovic, I used the --useSeparateProcesses flag instead of --skipCacheInvalidation and now it works with reloading on change.

[larswww]

--skipCacheInvalidation worked for me, but gave me problems in production. This solved it in my case;
`let user
try {
sled = mongoose.connection.model('User')
} catch (e) {
user = mongoose.model('User', UserSchema)
}

module.exports = user`

[KunalAwasthiKooky]

Hello,

I run in the same problem.
Using the cli parameter --skipCacheInvalidation fixt it for me.

--skipCacheInvalidation -c Tells the plugin to skip require cache invalidation. A script reloading tool like Nodemon might then be needed.

can you share some links to integrate nodemon in serverless-http powered project?

[Elyx0]

--useSeparateProcesses breaks vscode debugger sadly

[phanorcoll]

@PabloEzequiel solution worked for me
let Dataset = mongoose.models.Dataset || mongoose.model('Dataset', DatasetSchema);

[anuj9196]

@gokul-t 's solution worked for me. Is there any issue with using global for all models? I have more than 10 models.

[nguyenthetoan]

--useSeparateProcesses is now renamed to --useChildProcesses
use --useChildProcesses works for me at the moment!
#768

[mohitnegi724]

When I use this solution
export const User = mongoose.models.User || mongoose.model('User', userSchema)

this gives Issue
User.findById is not a function

[tsaxena4k]

Adding this before schema declaration worked for me !

delete.mongoose.connection.models["name_of_your_model"];

[khalafalla]

How this comment don't have million like

[premraval-pr]

Thanks to @adrianovalente and @gokul-t that I could solve this error.

Faced the same issue, gone through the discussion here, and liked both the approaches i.e. By @adrianovalente here and By @gokul-t here

The first approach gave a great TS autocompletion support in the handlers after adding Model Type which is one of the purposes for TS but it was a lot of extra code for me for each model

The second approach was clean and precise but I couldn't get the TS support and error handling in the handler, it just became JS.

Hence I used the Interface approach from TS and came up with the code below which is a bit precise and also uses TS as its most. Just sharing as it could be helpful to anyone in the future.

import { Document, Model, model, models, Schema } from "mongoose";

const userSchema: Schema = new Schema(
    {
        first_name: {
            type: String,
            required: true,
        },
        last_name: {
            type: String,
            required: true,
        },
    },
    {
        collection: "users",
    }
);

interface IUser extends Document {
    first_name: string;
    last_name: string;
}

export default (models.users
    ? models.users
    : model("users", userSchema)) as Model<IUser>;

[mahdisoultana]

@premraval-pr this is really good solution work in my case Thank you very much

[itsgratien]

Thanks to @adrianovalente and @gokul-t that I could solve this error.

Faced the same issue, gone through the discussion here, and liked both the approaches i.e. By @adrianovalente here and By @gokul-t here

The first approach gave a great TS autocompletion support in the handlers after adding Model Type which is one of the purposes for TS but it was a lot of extra code for me for each model

The second approach was clean and precise but I couldn't get the TS support and error handling in the handler, it just became JS.

Hence I used the Interface approach from TS and came up with the code below which is a bit precise and also uses TS as its most. Just sharing as it could be helpful to anyone in the future.

import { Document, Model, model, models, Schema } from "mongoose";

const userSchema: Schema = new Schema(
    {
        first_name: {
            type: String,
            required: true,
        },
        last_name: {
            type: String,
            required: true,
        },
    },
    {
        collection: "users",
    }
);

interface IUser extends Document {
    first_name: string;
    last_name: string;
}

export default (models.users
    ? models.users
    : model("users", userSchema)) as Model<IUser>;

Thank you for sharing.

[nyel-gh]

@premraval-pr This is exactly what I needed. Thanks!

[francosalcedo]

Thanks to @adrianovalente and @gokul-t that I could solve this error.

Faced the same issue, gone through the discussion here, and liked both the approaches i.e. By @adrianovalente here and By @gokul-t here

The first approach gave a great TS autocompletion support in the handlers after adding Model Type which is one of the purposes for TS but it was a lot of extra code for me for each model

The second approach was clean and precise but I couldn't get the TS support and error handling in the handler, it just became JS.

Hence I used the Interface approach from TS and came up with the code below which is a bit precise and also uses TS as its most. Just sharing as it could be helpful to anyone in the future.

import { Document, Model, model, models, Schema } from "mongoose";

const userSchema: Schema = new Schema(
    {
        first_name: {
            type: String,
            required: true,
        },
        last_name: {
            type: String,
            required: true,
        },
    },
    {
        collection: "users",
    }
);

interface IUser extends Document {
    first_name: string;
    last_name: string;
}

export default (models.users
    ? models.users
    : model("users", userSchema)) as Model<IUser>;

thanksss

[ghostwalkerj]

Perfect. This is exactly what I needed.