Impossibile sovrascrivere il modello una volta compilato Mongoose

Non sono sicuro di cosa sto sbagliando, ecco il mio 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 })
    });

ed ecco il mio 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); 
   });

Ogni volta che provo a eseguire check.js, ricevo questo errore

Non è possibile sovrascrivere il modello "utenti" una volta compilato .

Capisco che questo errore sia dovuto alla mancata corrispondenza dello schema, ma non riesco a vedere dove sta accadendo? Sono abbastanza nuovo per mangusta e nodeJS.

Ecco cosa ottengo dall'interfaccia client del mio 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 
  } 
>

L'errore si verifica perché hai già uno schema definito e quindi stai definendo di nuovo lo schema. In genere, ciò che dovresti fare è istanziare lo schema una volta e poi fare in modo che un oggetto globale lo chiami quando ne ha bisogno.

Per esempio:

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); 
});

Quindi un altro motivo per cui potresti ottenere questo errore è se usi lo stesso modello in file diversi ma il tuo require percorso ha un caso diverso. Ad esempio nella mia situazione ho avuto:

require('./models/User') in un file e poi in un altro file in cui avevo bisogno di accedere al modello utente che avevo require('./models/user') .

Immagino che la ricerca di moduli e mongoose lo tratti come un file diverso. Una volta che mi sono assicurato che il caso corrispondesse in entrambi, non era più un problema.

Ho avuto questo problema durante il test dell'unità.

La prima volta che chiami la funzione di creazione del modello, mangusta memorizza il modello con la chiave che fornisci (ad esempio "utenti"). Se chiami la funzione di creazione del modello con la stessa chiave più di una volta, mongoose non ti permetterà di sovrascrivere il modello esistente.

Puoi verificare se il modello esiste già in mangusta con:

let users = mongoose.model('users')

Questo genererà un errore se il modello non esiste, quindi puoi avvolgerlo in una prova / cattura per ottenere il modello o crearlo:

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

Ho avuto questo problema mentre "guardavo" i test. Quando i test sono stati modificati, l'orologio ha rieseguito i test, ma proprio per questo motivo hanno fallito.

L'ho risolto controllando se il modello esiste, quindi usalo, altrimenti crealo.

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

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

Ho riscontrato questo problema e non è stato a causa delle definizioni dello schema, ma piuttosto della modalità offline senza server: sono riuscito a risolverlo con questo:

serverless offline --skipCacheInvalidation

Che è menzionato qui https://github.com/dherault/serverless-offline/issues/258

Si spera che questo aiuti qualcun altro che sta costruendo il proprio progetto in modalità serverless e in esecuzione offline.

Se stai usando Serverless offline e non vuoi usare --skipCacheInvalidation, puoi usare molto bene:

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

Se l'hai fatto qui è possibile che tu abbia avuto lo stesso problema che ho avuto io. Il mio problema era che stavo definendo un altro modello con lo stesso nome . Ho chiamato la mia galleria e il mio modello di file "File". Maledizione, copia e incolla!

Questo è successo a me quando scrivo in questo modo:

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

Tuttavia, il vero percorso è "../myUser/User.js"

Ho risolto questo problema aggiungendo

mongoose.models = {}

prima della riga:

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

Spero che risolva il tuo problema

Per risolvere questo controllo se il modello esiste prima di eseguire la creazione:

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

So che esiste una soluzione accettata, ma ritengo che la soluzione attuale produca un sacco di boilerplate solo per poter testare i modelli. La mia soluzione consiste essenzialmente nel prendere il tuo modello e inserirlo in una funzione che restituisce il nuovo modello se il modello non è stato registrato, ma restituisce il modello esistente se lo è.

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()

Aprire e chiudere le connessioni ovunque è frustrante e non si comprime bene.

In questo modo se dovessi richiedere al modello due posti diversi o più specificamente nei miei test non otterrei errori e verranno restituite tutte le informazioni corrette.

Questo problema potrebbe verificarsi se si definiscono 2 diversi schemi con lo stesso nome di raccolta

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" } });

Ho avuto lo stesso problema, motivo per cui ho definito lo schema un modello in una funzione JS, dovrebbero essere definiti globalmente in un modulo nodo, non in una funzione.

C'è un altro modo per generare questo errore.

Tieni presente che il percorso del modello fa distinzione tra maiuscole e minuscole.

In questo esempio simile che coinvolge il modello "Categoria", l'errore è stato generato in queste condizioni:

1) L'istruzione require è stata menzionata in due file: ..category.js e ..index.js 2) Io il primo, il caso era corretto, nel secondo file non era il seguente:

category.js

index.js

La definizione dello schema dovrebbe essere univoca per una raccolta, non dovrebbe essere più di uno schema per una raccolta.

è perché il tuo schema è già, convalidalo prima di creare un nuovo schema.

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);

Puoi facilmente risolverlo facendo

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

Ho una situazione in cui devo creare il modello dinamicamente con ogni richiesta e per questo motivo ho ricevuto questo errore, tuttavia, quello che ho usato per risolverlo è utilizzare il metodo deleteModel come segue:

var contentType = 'Product'

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

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

mongoose.deleteModel(contentType);

Spero che questo possa aiutare chiunque.

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.

Per tutte le persone che finiscono qui a causa di un codice base con un mix di Typegoose e Mongoose :

Crea una connessione db per ognuno:

Mangusta:

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

Tipo:

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

Ho solo un errore di copia e incolla. In una riga avevo lo stesso nome che in un altro modello (modello di annuncio):

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

Corretto è:

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

A proposito, se qualcuno ha "salvataggio automatico" e utilizza l'indice per query come:

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

Deve eliminare l'indice e riscrivere per il modello corretto:

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

Ho risolto questo problema in questo modo

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

const Schema = mongoose.Schema;

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

Quindi in altri file

// 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({});

Soluzione migliore

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

Spero che aiuti...

Poiché questo problema si è verificato perché ho chiamato il modello un'altra volta. Risolvi questo problema avvolgendo il codice del modello nel blocco try catch. il codice dattiloscritto è così -

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

Allo stesso modo puoi anche scrivere codice in js.

Stai utilizzando mongoose.model con lo stesso nome di variabile "utente" in check.js e insert.js.

Se stai lavorando con expressjs, potresti dover spostare la definizione del modello fuori da app.get () in modo che venga chiamata solo una volta quando viene creata un'istanza dello script.