No se puede sobrescribir el modelo una vez que se compiló la 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); }); 

Cada vez que bash ejecutar check.js, obtengo este error

No se puede sobrescribir el modelo de los usuarios una vez comstackdo .

Entiendo que este error se debe a un desajuste de Schema, pero no puedo ver dónde está sucediendo esto. Soy bastante nuevo para mongoose y nodeJS.

Esto es lo que obtengo de la interfaz del 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. En general, 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 podría obtener este error es si usa el mismo modelo en diferentes archivos, pero su ruta require tiene un caso diferente. Por ejemplo, en mi situación, tuve:

require('./models/User') en un archivo y luego en otro archivo donde necesitaba acceso al modelo de Usuario que require('./models/user') .

Creo que la búsqueda de módulos y mongoose es tratarlo como un archivo diferente. Una vez que me aseguré de que el caso coincidiera en ambos, ya no era un problema.

Tuve este problema mientras probaba la unidad.

La primera vez que llama a la función de creación de modelos, mongoose almacena el modelo debajo de la clave que proporciona (por ejemplo, ‘usuarios’). Si llama a la función de creación del modelo con la misma clave más de una vez, Mangosta no le permitirá sobrescribir el modelo existente.

Puede verificar si el modelo ya existe en mongoose con:

 let users = mongoose.model('users') 

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

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

Tuve este problema mientras ‘observaba’ las pruebas. Cuando se editaron las pruebas, el reloj volvió a ejecutar las pruebas, pero fracasaron debido a esta misma razón.

Lo arreglé comprobando si el modelo existe y luego lo usé, de lo contrario lo creé.

 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 de esquema sino por el modo fuera de línea sin servidor. Solo logré resolverlo con esto:

 serverless offline --skipCacheInvalidation 

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

Con suerte, eso ayuda a alguien más que está construyendo su proyecto sin servidor y ejecutando el modo fuera de línea.

Si lo hiciste aquí, es posible que tuvieras el mismo problema que yo. Mi problema era que estaba definiendo otro modelo con el mismo nombre . Llamé a mi galería y a mi modelo de archivo “Archivo”. ¡Maldito, copia y pega!

Sé que hay una solución aceptada, pero creo que la solución actual da como resultado una gran cantidad de plantillas para que pueda probar modelos. Mi solución es esencialmente tomar su modelo y colocarlo dentro de una función, lo que resulta en la devolución del nuevo modelo si el modelo no se ha registrado, pero devolviendo el modelo existente si lo tiene.

 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 todos lados es frustrante y no se comprime bien.

De esta forma, si tuviera que exigir al modelo dos lugares diferentes o más específicamente en mis pruebas, no obtendría errores y se devolvería toda la información correcta.

Esto me sucedió cuando escribo así:

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

Sin embargo, el verdadero camino es ‘../myUser/User.js’

Si está utilizando el modo sin servidor y no desea utilizar --skipCacheInvalidation , puede usar muy bien:

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

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

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

es porque su esquema ya está, validar 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); 
 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" } }); 

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