Không thể ghi đè mô hình sau khi đã biên dịch Mongoose

Không chắc mình đang làm gì sai, đây là séc của tôi.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 })
    });

và đây là insert.js của tôi

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

Bất cứ khi nào tôi cố gắng chạy check.js, tôi đều gặp lỗi này

Không thể ghi đè mô hình 'người dùng' sau khi được biên dịch .

Tôi hiểu rằng lỗi này xảy ra do Lược đồ không khớp, nhưng tôi không thể biết điều này đang xảy ra ở đâu? Tôi khá mới với mongoose và nodeJS.

Đây là những gì tôi nhận được từ giao diện khách hàng của MongoDB của tôi:

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ỗi xảy ra bởi vì bạn đã xác định một lược đồ và sau đó bạn đang xác định lại lược đồ. Nói chung, những gì bạn nên làm là khởi tạo giản đồ một lần và sau đó yêu cầu một đối tượng toàn cục gọi nó khi nó cần.

Ví dụ:

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

Vì vậy, một lý do khác khiến bạn có thể gặp phải Lỗi này là nếu bạn sử dụng cùng một mô hình trong các tệp khác nhau nhưng requiređường dẫn của bạn có trường hợp khác. Ví dụ trong tình huống của tôi, tôi đã có:

require('./models/User')trong một tệp và sau đó trong một tệp khác mà tôi cần quyền truy cập vào Mô hình người dùng mà tôi có require('./models/user').

Tôi đoán tìm kiếm mô-đun & mongoose đang coi nó như một tệp khác. Khi tôi đã chắc chắn rằng trường hợp phù hợp với cả hai thì nó không còn là vấn đề nữa.

Tôi đã gặp sự cố này trong khi thử nghiệm đơn vị.

Lần đầu tiên bạn gọi hàm tạo mô hình, mongoose sẽ lưu trữ mô hình dưới khóa bạn cung cấp (ví dụ: 'người dùng'). Nếu bạn gọi hàm tạo mô hình bằng cùng một phím nhiều lần, mongoose sẽ không cho phép bạn ghi đè lên mô hình hiện có.

Bạn có thể kiểm tra xem mô hình đã tồn tại trong mongoose hay chưa bằng:

let users = mongoose.model('users')

Điều này sẽ gây ra lỗi nếu mô hình không tồn tại, vì vậy bạn có thể gói nó trong một lần thử / bắt để lấy mô hình hoặc tạo mô hình:

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

Tôi đã gặp sự cố này khi 'xem' các bài kiểm tra. Khi các bài kiểm tra được chỉnh sửa, đồng hồ chạy lại các bài kiểm tra, nhưng chúng không thành công do chính lý do này.

Tôi đã sửa nó bằng cách kiểm tra nếu mô hình tồn tại thì hãy sử dụng nó, nếu không hãy tạo nó.

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

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

Tôi đã gặp phải sự cố này & đó không phải do định nghĩa giản đồ mà là do chế độ ngoại tuyến không có máy chủ - tôi chỉ giải quyết được nó bằng cách này:

serverless offline --skipCacheInvalidation

Được đề cập ở đây https://github.com/dherault/serverless-offline/issues/258

Hy vọng rằng điều đó sẽ giúp những người khác đang xây dựng dự án của họ trên máy chủ và đang chạy chế độ ngoại tuyến.

Nếu bạn đang sử dụng Serverless ngoại tuyến và không muốn sử dụng --skipCacheInvalidation, bạn rất có thể sử dụng:

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

Nếu bạn thực hiện ở đây, có thể bạn đã gặp phải vấn đề tương tự như tôi đã làm. Vấn đề của tôi là tôi đang xác định một mô hình khác có cùng tên . Tôi đã gọi thư viện và mô hình tệp của mình là "Tệp". Darn bạn sao chép và dán!

Điều này đã xảy ra với tôi khi tôi viết như thế này:

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

Tuy nhiên, đường dẫn thực sự là '../myUser/User.js'

Tôi đã giải quyết điều này bằng cách thêm

mongoose.models = {}

trước dòng:

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

Hy vọng nó giải quyết được vấn đề của bạn

Để giải quyết vấn đề này, hãy kiểm tra xem mô hình có tồn tại trước đó hay không để thực hiện việc tạo:

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

Tôi biết có một giải pháp được chấp nhận nhưng tôi cảm thấy rằng giải pháp hiện tại dẫn đến rất nhiều bản ghi sẵn chỉ để bạn có thể kiểm tra Mô hình. Giải pháp của tôi về cơ bản là đưa bạn mô hình và đặt nó vào bên trong một chức năng dẫn đến trả về Mô hình mới nếu Mô hình chưa được đăng ký nhưng trả về Mô hình hiện có nếu có.

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

Mở và đóng các kết nối khắp nơi là bực bội và không nén tốt.

Bằng cách này nếu tôi yêu cầu mô hình ở hai nơi khác nhau hoặc cụ thể hơn trong các thử nghiệm của mình, tôi sẽ không gặp lỗi và tất cả thông tin chính xác sẽ được trả lại.

Sự cố này có thể xảy ra nếu bạn xác định 2 lược đồ khác nhau có cùng tên Bộ sưu tập

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

Tôi đã gặp vấn đề tương tự, lý do là tôi đã xác định lược đồ một mô hình trong một hàm JS, chúng phải được định nghĩa toàn cục trong một mô-đun nút, không phải trong một hàm.

Có một cách khác để loại bỏ lỗi này.

Hãy nhớ rằng đường dẫn đến mô hình có phân biệt chữ hoa chữ thường.

Trong ví dụ tương tự này liên quan đến mô hình "Danh mục", lỗi đã xảy ra trong các điều kiện sau:

1) Câu lệnh request đã được đề cập trong hai tệp: ..category.js và ..index.js 2) Tôi là trường hợp đầu tiên, đúng, trong tệp thứ hai, nó không như sau:

category.js

index.js

Định nghĩa lược đồ phải là duy nhất cho một tập hợp, không nên có nhiều hơn một lược đồ cho một tập hợp.

là do lược đồ của bạn đã có, hãy xác thực trước khi tạo lược đồ mới.

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

Bạn có thể dễ dàng giải quyết vấn đề này bằng cách

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

Tôi gặp tình huống phải tạo mô hình động với mỗi yêu cầu và do đó tôi nhận được lỗi này, tuy nhiên, những gì tôi đã sử dụng để khắc phục nó là sử dụng phương thức deleteModel như sau:

var contentType = 'Product'

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

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

mongoose.deleteModel(contentType);

Tôi hy vọng điều này có thể giúp bất kỳ ai.

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.

Đối với tất cả những người kết thúc ở đây vì cơ sở mã có sự kết hợp của Typegoose và Mongoose :

Tạo kết nối db cho từng kết nối:

Mongoose:

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

Typegoose:

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

Tôi chỉ có một bản sao dán nhầm. Trong một dòng, tôi có cùng tên trong mô hình khác (Mô hình quảng cáo):

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

Đúng là:

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

Nhân tiện, nếu ai đó có "tự động lưu" và sử dụng chỉ mục cho các truy vấn như:

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

Nó phải xóa chỉ mục và viết lại cho đúng mô hình:

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

Tôi đã giải quyết vấn đề này bằng cách làm điều này

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

const Schema = mongoose.Schema;

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

Sau đó, trong các tệp khác

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

Giải pháp tốt hơn

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

Tôi hi vọng cái này giúp được...

Kể từ khi vấn đề này xảy ra bởi vì cuộc gọi mô hình lần khác. Khắc phục sự cố này bằng cách gói mã mô hình của bạn trong khối thử bắt. mã typecript như thế này -

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

Tương tự, bạn cũng có thể viết mã bằng js.

Bạn đang sử dụng mongoose.model với cùng một tên biến "user" trong check.js và insert.js.

Nếu đang làm việc với expressj, bạn có thể cần phải di chuyển định nghĩa mô hình của mình ra bên ngoài app.get () để nó chỉ được gọi một lần khi tập lệnh được khởi tạo.