Nie można nadpisać modelu po skompilowaniu Mongoose

Nie wiem, co robię źle, oto mój 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 })
    });

a oto mój 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); 
   });

Za każdym razem, gdy próbuję uruchomić check.js, pojawia się ten błąd

Po skompilowaniu nie można nadpisać modelu „użytkowników” .

Rozumiem, że ten błąd wynika z niedopasowania schematu, ale nie widzę, gdzie to się dzieje? Jestem całkiem nowy w Mongoose i nodeJS.

Oto, co otrzymuję z interfejsu klienta mojej 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 
  } 
>

Błąd występuje, ponieważ masz już zdefiniowany schemat, a następnie definiujesz go ponownie. Ogólnie rzecz biorąc, powinieneś raz utworzyć wystąpienie schematu, a następnie wywołać go, gdy będzie potrzebny obiekt globalny.

Na przykład:

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

Więc innym powodem, dla którego możesz otrzymać ten błąd, jest użycie tego samego modelu w różnych plikach, ale requireścieżka ma inny przypadek. Na przykład w mojej sytuacji miałem:

require('./models/User')w jednym pliku, a następnie w innym, gdzie potrzebowałem dostępu do modelu użytkownika, który miałem require('./models/user').

Wydaje mi się, że wyszukiwanie modułów i mongoose traktuje go jako inny plik. Kiedy upewniłem się, że przypadek pasuje w obu przypadkach, nie było to już problemem.

Miałem ten problem podczas testów jednostkowych.

Przy pierwszym wywołaniu funkcji tworzenia modelu mongoose przechowuje model pod podanym kluczem (np. „Użytkownicy”). Jeśli wywołasz funkcję tworzenia modelu z tym samym kluczem więcej niż raz, mangusta nie pozwoli Ci nadpisać istniejącego modelu.

Możesz sprawdzić, czy model już istnieje w mangusta za pomocą:

let users = mongoose.model('users')

Spowoduje to wyświetlenie błędu, jeśli model nie istnieje, więc możesz zawinąć go w try / catch, aby uzyskać model lub go utworzyć:

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

Miałem ten problem podczas „oglądania” testów. Po edycji testów zegarek ponownie je przeprowadził, ale z tego właśnie powodu zakończyły się niepowodzeniem.

Naprawiłem to, sprawdzając, czy model istnieje, a następnie użyj go, w przeciwnym razie utwórz.

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

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

Doświadczałem tego problemu i nie było to spowodowane definicjami schematu, ale raczej bezserwerowym trybem offline - właśnie udało mi się go rozwiązać w ten sposób:

serverless offline --skipCacheInvalidation

O czym wspomniano tutaj https://github.com/dherault/serverless-offline/issues/258

Mam nadzieję, że pomoże to komuś, kto buduje swój projekt w trybie bezserwerowym i działa w trybie offline.

Jeśli używasz Serverless w trybie offline i nie chcesz używać --skipCacheInvalidation, możesz bardzo dobrze użyć:

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

Jeśli zrobiłeś to tutaj, możliwe, że miałeś ten sam problem, co ja. Mój problem polegał na tym, że definiowałem inny model o tej samej nazwie . Nazwałem moją galerię i model pliku „Plik”. Cholera, kopiuj i wklejaj!

Przydarzyło mi się to, kiedy piszę tak:

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

Jednak prawdziwa ścieżka to „../myUser/User.js”

Rozwiązałem to, dodając

mongoose.models = {}

przed linią:

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

Mam nadzieję, że to rozwiązuje twój problem

Aby rozwiązać ten problem, sprawdź, czy model istnieje przed utworzeniem:

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

Wiem, że istnieje akceptowalne rozwiązanie, ale uważam, że obecne rozwiązanie prowadzi do wielu schematów, abyś mógł przetestować modele. Moje rozwiązanie polega w istocie na przeniesieniu modelu i umieszczeniu go wewnątrz funkcji powodującej zwrócenie nowego Modelu, jeśli Model nie został zarejestrowany, ale zwraca istniejący Model, jeśli tak.

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

Otwieranie i zamykanie połączeń w każdym miejscu jest frustrujące i nie uciska dobrze.

W ten sposób, gdybym wymagał od modelu dwóch różnych miejsc lub dokładniej w moich testach, nie dostałbym błędów i zwracane są wszystkie prawidłowe informacje.

Ten problem może wystąpić, jeśli zdefiniujesz 2 różne schematy o tej samej nazwie kolekcji

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

Miałem ten sam problem, ponieważ zdefiniowałem schemat i model w funkcji JS, powinny być zdefiniowane globalnie w module węzła, a nie w funkcji.

Istnieje inny sposób na zgłoszenie tego błędu.

Należy pamiętać, że w ścieżce do modelu rozróżniana jest wielkość liter.

W tym podobnym przykładzie dotyczącym modelu „Kategoria” błąd został zgłoszony w następujących warunkach:

1) Wymagane stwierdzenie pojawiło się w dwóch plikach: ..category.js i ..index.js 2) W pierwszym przypadku sprawa była poprawna, w drugim nie było tak:

category.js

index.js

Definicja schematu powinna być unikalna dla kolekcji, nie powinna zawierać więcej niż jednego schematu dla kolekcji.

wynika z tego, że Twój schemat już istnieje, sprawdź poprawność przed utworzeniem nowego schematu.

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

Możesz łatwo rozwiązać ten problem, robiąc

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

Mam sytuację, w której muszę dynamicznie tworzyć model z każdym żądaniem i przez to otrzymałem ten błąd, jednak to, co naprawiłem, to metoda deleteModel jak poniżej:

var contentType = 'Product'

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

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

mongoose.deleteModel(contentType);

Mam nadzieję, że to mogłoby pomóc każdemu.

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.

Dla wszystkich osób kończących się tutaj z powodu bazy kodów z mieszanką Typegoose i Mongoose :

Utwórz połączenie db dla każdego z nich:

Mangusta:

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

Typegoose:

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

Po prostu mam błąd wklejania kopii. W jednej linii miałem taką samą nazwę jak w innym modelu (model reklamowy):

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

Prawidłowe to:

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

Nawiasem mówiąc, jeśli ktoś ma „automatyczne zapisywanie” i używa indeksu do zapytań takich jak:

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

Musi usunąć indeks i przepisać na poprawny model:

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

Rozwiązałem ten problem, robiąc to

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

const Schema = mongoose.Schema;

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

Następnie w innych plikach

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

Lepsze rozwiązanie

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

Mam nadzieję, że to pomoże...

Ponieważ ten problem wystąpił z powodu innego wywołania modelu. Obejdź ten problem, opakowując kod modelu w bloku try catch. kod maszynowy wygląda następująco -

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

Podobnie możesz pisać kod w js.

Używasz mongoose.model z tą samą nazwą zmiennej „user” w check.js i insert.js.

Jeśli pracujesz z expressjs, może być konieczne przeniesienie definicji modelu poza app.get (), aby była wywoływana tylko raz, gdy skrypt jest tworzony.