No se puede sobrescribir el modelo una vez compilado Mongoose

No estoy seguro de lo que estoy haciendo mal, aquí está mi check.js

var db = mongoose.createConnection('localhost', 'event-db');
db.on('error', console.error.bind(console, 'connection error:'));

var a1= db.once('open',function(){
var user = mongoose.model('users',{ 
       name:String,
       email:String,
       password:String,
       phone:Number,
      _enabled:Boolean
     });

user.find({},{},function (err, users) {
    mongoose.connection.close();
    console.log("Username supplied"+username);
    //doSomethingHere })
    });

y aquí está mi insert.js

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/event-db')

var user = mongoose.model('users',{
     name:String,
     email:String,
     password: String,
     phone:Number,
     _enabled:Boolean
   });

var new_user = new user({
     name:req.body.name,
     email: req.body.email,
     password: req.body.password,
     phone: req.body.phone,
     _enabled:false
   });

new_user.save(function(err){
    if(err) console.log(err); 
   });

Siempre que intento ejecutar check.js, aparece este error

No se puede sobrescribir el modelo de 'usuarios' una vez compilado .

Entiendo que este error se debe a que el esquema no coincide, pero no puedo ver dónde está sucediendo. Soy bastante nuevo en mangosta y nodeJS.

Esto es lo que obtengo de la interfaz de cliente de mi MongoDB:

MongoDB shell version: 2.4.6 connecting to: test 
> use event-db 
  switched to db event-db 
> db.users.find() 
  { "_id" : ObjectId("52457d8718f83293205aaa95"), 
    "name" : "MyName", 
    "email" : "myemail@me.com", 
    "password" : "myPassword", 
    "phone" : 900001123, 
    "_enable" : true 
  } 
>

El error se produce porque ya tiene un esquema definido y luego está definiendo el esquema nuevamente. Generalmente, lo que debe hacer es crear una instancia del esquema una vez y luego hacer que un objeto global lo llame cuando lo necesite.

Por ejemplo:

user_model.js

var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var userSchema = new Schema({
   name:String,
   email:String,
   password:String,
   phone:Number,
   _enabled:Boolean
});
module.exports = mongoose.model('users', userSchema);          

check.js

var mongoose = require('mongoose');
var User = require('./user_model.js');

var db = mongoose.createConnection('localhost', 'event-db');
db.on('error', console.error.bind(console, 'connection error:'));
var a1= db.once('open',function(){
  User.find({},{},function (err, users) {
    mongoose.connection.close();
    console.log("Username supplied"+username);
    //doSomethingHere 
  })
});

insert.js

var mongoose = require('mongoose');
var User = require('./user_model.js');

mongoose.connect('mongodb://localhost/event-db');
var new_user = new User({
    name:req.body.name
  , email: req.body.email
  , password: req.body.password
  , phone: req.body.phone
  , _enabled:false 
});
new_user.save(function(err){
  if(err) console.log(err); 
});

Entonces, otra razón por la que puede obtener este error es si usa el mismo modelo en diferentes archivos pero su requireruta tiene un caso diferente. Por ejemplo en mi situación tuve:

require('./models/User')en un archivo y luego en otro archivo donde necesitaba acceder al modelo de usuario que tenía require('./models/user').

Supongo que la búsqueda de módulos y mangosta lo trata como un archivo diferente. Una vez que me aseguré de que el caso coincidiera en ambos, ya no fue un problema.

Tuve este problema durante la prueba unitaria.

La primera vez que llama a la función de creación de modelo, mangosta almacena el modelo bajo la clave que usted proporciona (por ejemplo, 'usuarios'). Si llama a la función de creación del modelo con la misma clave más de una vez, la mangosta no le permitirá sobrescribir el modelo existente.

Puedes comprobar si el modelo ya existe en mangosta con:

let users = mongoose.model('users')

Esto arrojará un error si el modelo no existe, por lo que puede envolverlo en un intento / captura para obtener el modelo o crearlo:

let users
try {
  users = mongoose.model('users')
} catch (error) {
  users = mongoose.model('users', <UsersSchema...>)
}

Tuve este problema mientras 'miraba' las pruebas. Cuando se editaron las pruebas, el reloj volvió a ejecutar las pruebas, pero fallaron debido a esta misma razón.

Lo arreglé verificando si el modelo existe y luego lo usé, de lo contrario, créelo.

import mongoose from 'mongoose';
import user from './schemas/user';

export const User = mongoose.models.User || mongoose.model('User', user);

He estado experimentando este problema y no fue por las definiciones del esquema, sino por el modo fuera de línea sin servidor; simplemente logré resolverlo con esto:

serverless offline --skipCacheInvalidation

Que se menciona aquí https://github.com/dherault/serverless-offline/issues/258

Con suerte, eso ayudará a alguien más que esté construyendo su proyecto en modo sin servidor y sin conexión.

Si está utilizando Serverless sin conexión y no desea utilizarlo --skipCacheInvalidation, puede utilizar:

module.exports = mongoose.models.Users || mongoose.model('Users', UsersSchema);

Si llegó aquí, es posible que haya tenido el mismo problema que yo. Mi problema fue que estaba definiendo otro modelo con el mismo nombre . Llamé a mi galería y mi modelo de archivo "Archivo". ¡Maldita sea, copia y pega!

Esto me pasó a mí cuando escribo así:

import User from '../myuser/User.js';

Sin embargo, la verdadera ruta es '../myUser/User.js'

Resolví esto agregando

mongoose.models = {}

antes de la línea:

mongoose.model(<MODEL_NAME>, <MODEL_SCHEMA>)

Espero que resuelva tu problema

Para resolver esta comprobación si el modelo existe antes de realizar la creación:

if (!mongoose.models[entityDBName]) {
  return mongoose.model(entityDBName, entitySchema);
}
else {
  return mongoose.models[entityDBName];
}

Sé que hay una solución aceptada, pero creo que la solución actual da como resultado una gran cantidad de texto estándar solo para que pueda probar los modelos. Mi solución es esencialmente tomar su modelo y colocarlo dentro de una función, lo que resulta en devolver el nuevo modelo si el modelo no se ha registrado, pero devolver el modelo existente si lo ha hecho.

function getDemo () {
  // Create your Schema
  const DemoSchema = new mongoose.Schema({
    name: String,
    email: String
  }, {
    collection: 'demo'
  })
  // Check to see if the model has been registered with mongoose
  // if it exists return that model
  if (mongoose.models && mongoose.models.Demo) return mongoose.models.Demo
  // if no current model exists register and return new model
  return mongoose.model('Demo', DemoSchema)
}

export const Demo = getDemo()

Abrir y cerrar conexiones por todas partes es frustrante y no se comprime bien.

De esta manera, si requiriera el modelo en dos lugares diferentes o más específicamente en mis pruebas, no obtendría errores y se devuelve toda la información correcta.

Este problema puede ocurrir si define 2 esquemas diferentes con el mismo nombre de colección

If you want to overwrite the existing class for different collection using typescript
then you have to inherit the existing class from different class.

export class User extends Typegoose{
  @prop
  username?:string
  password?:string
}


export class newUser extends User{
    constructor() {
        super();
    }
}

export const UserModel = new User ().getModelForClass(User , { schemaOptions: { collection: "collection1" } });

export const newUserModel = new newUser ().getModelForClass(newUser , { schemaOptions: { collection: "collection2" } });

Tuve el mismo problema, la razón fue que definí el esquema de un modelo en una función JS, deberían definirse globalmente en un módulo de nodo, no en una función.

Hay otra forma de lanzar este error.

Tenga en cuenta que la ruta al modelo distingue entre mayúsculas y minúsculas.

En este ejemplo similar que involucra el modelo "Categoría", el error se produjo en estas condiciones:

1) La declaración require se mencionó en dos archivos: ..category.js y ..index.js 2) En el primero, el caso era correcto, en el segundo archivo no era el siguiente:

category.js

index.js

La definición de esquema debe ser única para una colección, no debe ser más de un esquema para una colección.

es porque su esquema ya está, valide antes de crear un nuevo esquema.

var mongoose = require('mongoose');
module.exports = function () {
var db = require("../libs/db-connection")();
//schema de mongoose
var Schema = require("mongoose").Schema;

var Task = Schema({
    field1: String,
    field2: String,
    field3: Number,
    field4: Boolean,
    field5: Date
})

if(mongoose.models && mongoose.models.tasks) return mongoose.models.tasks;

return mongoose.model('tasks', Task);

Puede resolver esto fácilmente haciendo

delete mongoose.connection.models['users'];
const usersSchema = mongoose.Schema({...});
export default mongoose.model('users', usersSchema);

Tengo una situación en la que tengo que crear el modelo dinámicamente con cada solicitud y debido a eso recibí este error, sin embargo, lo que usé para solucionarlo es usar el método deleteModel como el siguiente:

var contentType = 'Product'

var contentSchema = new mongoose.Schema(schema, virtuals);

var model = mongoose.model(contentType, contentSchema);

mongoose.deleteModel(contentType);

Espero que esto pueda ayudar a cualquiera.

The reason of this issue is: 

you given the model name "users" in the line 
<<<var user = mongoose.model('users' {>>> in check.js file

and again the same model name you are giving in the insert file
<<< var user = mongoose.model('users',{ >>> in insert.js

This "users" name shouldn't be same when you declare a model that should be different 
in a same project.

Para todas las personas que terminan aquí debido a una base de código con una mezcla de Typegoose y Mongoose :

Cree una conexión de base de datos para cada uno:

Mangosta:

module.exports = db_mongoose.model("Car", CarSchema);

Tipo ganso:

db_typegoose.model("Car", CarModel.schema, "cars");

Solo tengo un error al copiar y pegar. En una línea tenía el mismo nombre que en otro modelo (modelo de anuncio):

const Admin = mongoose.model('Ad', adminSchema);

Correcto es:

const Admin = mongoose.model('Admin', adminSchema);

Por cierto, si alguien tiene "guardado automático" y usa el índice para consultas como:

**adSchema**.index({title:"text", description:"text", phone:"text", reference:"text"})

Tiene que eliminar el índice y reescribir para el modelo correcto:

**adminSchema**.index({title:"text", description:"text", phone:"text", reference:"text"})

Resolví este problema haciendo esto

// Created Schema - Users
// models/Users.js
const mongoose = require("mongoose");

const Schema = mongoose.Schema;

export const userSchema = new Schema({
  // ...
});

Luego en otros archivos

// Another file
// index.js
import { userSchema } from "../models/Users";
const conn = mongoose.createConnection(process.env.CONNECTION_STRING, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
});
conn.models = {};
const Users = conn.model("Users", userSchema);
const results = await Users.find({});

Mejor solucion

let User;
try {
  User = mongoose.model("User");
} catch {
  User = mongoose.model("User", userSchema);
}

Espero que esto ayude...

Dado que este problema ocurrió porque llamar al modelo en otro momento. Solucione este problema ajustando el código de su modelo en el bloque try catch. el código mecanografiado es así:

         Import {Schema, model} from 'mongoose';
         export function user(){
              try{
                   return model('user', new Schema ({
                            FirstName: String,
                            Last name: String
                     }));
              }
             catch{
                   return model('user');
              }
         }

Del mismo modo, también puede escribir código en js.

Estás usando mongoose.model con el mismo nombre de variable "usuario" en check.js e insert.js.

Si está trabajando con expressjs, es posible que deba mover la definición de su modelo fuera de app.get (), por lo que solo se llama una vez cuando se crea una instancia del script.