不能覆盖编译后的模型

之所以出现这个错误，是因为您已经定义了一个模式，然后又要重新定义该模式。通常，您应该做的是实例化模式一次，然后让一个全局对象在需要时调用它。

例如:

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

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

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

如果你来到这里，有可能你和我有同样的问题。 我的问题是 我在定义另一个同名模型。 我叫我的画廊和我的档案模型“文件”。该死的复制和粘贴！

您可能会得到这个错误的另一个原因是，如果您在不同的文件中使用相同的模型，但是您的 require路径有不同的情况。

例如，在我的情况下，我在一个文件中有 require('./models/User')，然后在另一个文件中，我需要访问用户模型，我有 require('./models/user')。

我猜是在模块和猫鼬的查找中把它当成了一个不同的文件。一旦我确定这两种情况都符合，那就不再是问题了。

如果使用 Expressjs，则可能需要将模型定义移到 app.get ()之外，因此在实例化脚本时只调用一次。

我在进行单元测试时遇到了这个问题。

第一次调用模型创建函数时，猫鼬将模型存储在您提供的键下(例如“用户”)。如果您使用相同的键多次调用模型创建函数，猫鼬不会让您覆盖现有的模型。

你可以用下面的方法检查猫鼬是否已经存在这个模型:

let users = mongoose.model('users')

如果模型不存在，这将抛出一个错误，因此您可以将其包装在 try/catch 中以获取模型或创建模型:

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

架构定义对于集合应该是唯一的，对于集合不应该是多个架构。

我知道有一个被接受的解决方案，但是我觉得当前的解决方案会产生很多样板，这样您就可以测试模型了。我的解决方案基本上是将您的模型放在一个函数中，如果模型没有注册，则返回新的模型，如果注册了，则返回现有的模型。

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

到处打开和关闭连接是令人沮丧的，并且压缩不好。

这样，如果我需要模型两个不同的地方，或者在我的测试中更具体一些，我就不会得到错误，并且所有正确的信息都会被返回。

我在“观看”考试时遇到了这个问题。 当测试被编辑后，手表会重新运行测试，但正是由于这个原因，测试失败了。

我通过检查模型是否存在来修复它，然后使用它，否则创建它。

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


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

当我这样写的时候，就发生了这样的事情:

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

但是，真正的路径是’. ./myUser/User.js’

我一直在经历这个问题，并不是因为模式的定义，而是因为无服务器的脱机模式-我只是设法解决这个问题:

serverless offline --skipCacheInvalidation

这里提到的 https://github.com/dherault/serverless-offline/issues/258

希望这能帮助其他在无服务器和离线模式下构建项目的人。

如果使用相同的 Collection 名称定义两个不同的模式，则可能会发生此问题

是因为您的模式已经在创建新模式之前进行了验证。

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

如果您正在使用脱机 Serverless，并且不想使用 --skipCacheInvalidation，那么您可以很好地使用:

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

你可以很容易地解决这个问题

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

我有一个情况，我必须动态地创建模型与每个请求，因为我收到了这个错误，但是，我用来修复它是使用 删除模型方法，如下所示:

var contentType = 'Product'


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


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


mongoose.deleteModel(contentType);

我希望这能帮到任何人。

我用加法解决了这个问题

mongoose.models = {}

在这句话之前:

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

希望能解决你的问题

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.

要解决这个问题，请检查模型是否存在，然后进行创建:

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

对于那些因为一个混合了 打字机和 猫鼬的代码库而在这里结束的人:

为每个连接创建一个 db 连接:

猫鼬:

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

打字机:

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

我也有同样的问题, 原因是我在 JS 函数中定义了模式模型，它们应该在节点模块中全局定义，而不是在函数中。

还有另一种抛出此错误的方法。

请记住，模型的路径是区分大小写的。

在这个涉及“分类”模型的类似例子中，错误是在以下条件下抛出的:

1)在两个文件中提到了 need 语句: . classy.js 和. index.js 2)第一，情况是正确的，在第二个档案中，情况不是这样的:

分类

Index.js

您正在 check.js 和 insert. js 中使用具有相同变量名“ user”的 mongoose.model。

我只是复制粘贴错误。在一行我有相同的名字在其他模型(广告模型) :

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

正确答案是:

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

顺便说一下，如果有人有“自动保存”，并使用索引查询，如:

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

它必须删除索引，并重写正确的模型:

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

由于这个问题的发生，因为调用模型的另一个时间。解决这个问题的方法是将模型代码包装在 try catch 块中。类型脚本代码是这样的-

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

类似地，您也可以用 js 编写代码。

我通过这样做解决了这个问题

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


const Schema = mongoose.Schema;


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

然后在其他文件里

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

更好的解决方案

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

我希望这能帮上忙。

这可能会给一些命中，但我也得到了错误，并意识到我只是拼错了用户模型导入。

错: const User = require('./UserModel'); 正确: const User = require('./userModel');

难以置信，但你想想。

您还可以在导出时做的是，确保导出现有的实例(如果存在的话)。

打字稿解决方案:

import { Schema, Document, model, models } from 'mongoose';


const UserSchema: Schema = new Schema({
name: {
type: String
}
});


export interface IUser extends Document {
name: string
}


export default models.Users || model<IUser>('Users', UserSchema);

这里还有一个原因可以解释为什么会发生这种情况。也许这能帮到别人。请注意差异，Member<是的trong>是的对成员。他们一定是一样的..。

export default mongoose.models.Members || mongoose.model('Member', FamilySchema)

改为:

export default mongoose.models.Member || mongoose.model('Member', FamilySchema)

像这样出口 User = mongoose.model. User | | mongoose.model (‘ User’，userSchema) ;

有这么多好的答案，但为了检查，我们可以做更容易的工作。 我的意思是，在最流行的答案里，有 check.js，我们的人把事情搞得很复杂，我建议:

function connectToDB() {
if (mongoose.connection.readyState === 1) {
console.log("already connected");
return;
}
mongoose.connect(
process.env.MONGODB_URL,
{
useCreateIndex: true,
useFindAndModify: false,
useNewUrlParser: true,
useUnifiedTopology: true,
},
(err) => {
if (err) throw err;
console.log("DB connected");
},
);
}

ReadyState = = 1表示连接
所以不要再尝试联系了
所以你不会得到错误
我认为这是因为连接，而它是连接
它是连接到 db 的另一种方式

我在使用 Next.js 和 TypeScript 时遇到了这个问题。

这就是对我有效的方法:

const { Schema } = mongoose


export interface IUser {
name: string
email: string
}


const UserSchema = new Schema<IUser>({
name: { type: String, required: true },
email: { type: String, required: true },
})


const UserModel = () => mongoose.model<IUser>('User', UserSchema)


export default (mongoose.models.User || UserModel()) as ReturnType<
typeof UserModel
>

我在使用 NextJS 和 MongoDB 地图集时遇到了同样的问题 存储会话模型，但问题不在于我定义了 Schema 两次。

1. 确保 Collection 为空并且没有以前的 Document
2. 如果是这样，那么简单地声明一个没有 Schema 的模型，像这样:

const Session = mongoose.model("user_session_collection")

3. 您可以删除或备份以前的记录，创建架构，然后对数据库应用查询。

希望有帮助

点击 给你! 官方示例。 大多数 重要的事是这样出口的

export default mongoose.models.Item || mongoose.model('Item', itemsSchema)

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


const userSchema = new Schema({
name: String,
});


// Trying to get the existing model to avoid OverwriteModelError
module.exports = mongoose.model("user") || mongoose.model('user', userSchema);

下面是 猫鼬与 分页结合使用 下一个和 打印稿时类似问题的完整解决方案:

import {model, models, Schema, PaginateModel, Document } from 'mongoose';


import { default as mongoosePaginate } from 'mongoose-paginate-v2';


export interface IUser extends Document {
name: string;
}


const UserSchema: Schema = new Schema({
name: String
});


UserSchema.plugin(mongoosePaginate)


interface User<T extends Document> extends PaginateModel<T> {}




const User: User<IUser> = models['User'] as User<IUser> || model<IUser>('User', UserSchema) as User<IUser>;


export default User

返回文章页面

{
"compilerOptions": {
"target": "ES2018",
"module": "ESNext",
"moduleResolution": "Node",
"lib": ["ESNext", "ESNext.AsyncIterable", "DOM"],
"esModuleInterop": true,
"allowJs": true,
"sourceMap": true,
"strict": true,
"noEmit": true,
"baseUrl": ".",
"paths": {
"~/*": ["./*"],
"@/*": ["./*"]
},
"types": ["@types/node", "@nuxt/types"]
},
"exclude": ["node_modules"]
}

要使分页工作，您还需要安装 @types/mongoose-paginate-v2

上面的解决方案还应该处理与热重载 Nuxt (ServerMiddleware错误)和分页插件注册有关的问题。

添加此行将100% 解决您的错误。

mongoose.models = {}

确保对两个不同的架构使用的模型名称不相同。

例如:

// course model
const mongoose = require("mongoose");
const courseSchema = new mongoose.Schema({
course: {
type: String,
required: true,
},
course_category: {
type: String,
required: true,
}
});
module.exports = mongoose.model("course", courseSchema);


// student model
const mongoose = require("mongoose");
const studentSchema = new mongoose.Schema({
first_name: {
type: String,
required: true,
},
last_name: {
type: String,
required: true,
}
});
module.exports = mongoose.model("course", studentSchema);

我的错误我在其他情态动词中使用相同的名字“用户”

const ProductSchema = new mongoose.Schema({
title: { type: String, required: true, unique: true },
desc: { type: String, required: true },
img: { type: String, required: true },
categorires: { type: Array },
size: { type: String },
color: { type: String },
price: { type: Number, required: true },
},
{ timestamps: true }
);


module.exports = mongoose.model("User", ProductSchema);```






*** Edit this line by me work look in your madels ***




module.exports = mongoose.model("Product", ProductSchema)

如果您正在使用脱机 Serverless，其中一个应该可以解决这个问题

--skipCacheInvalidation

或者

--useSeparateProcesses

尤其是现在这个

--useChildProcesses

对我有效的解决方案只是在创建和导出模型之前检查模型的实例是否存在。

import mongoose from "mongoose";
const { Schema } = mongoose;
const mongoosePaginate = require("mongoose-paginate");


const articleSchema = new Schema({
title: String, // String is shorthand for {type: String}
summary: String,
data: String,
comments: [{ body: String, date: Date }],
date: { type: Date, default: Date.now },
published: { type: Boolean, default: true },
tags: [{ name: String }],
category: String,
_id: String,
});




const Post = mongoose.models.Post ? mongoose.models.Post : mongoose.model("Post",articleSchema);


export default Post;

根据答案: https://stackoverflow.com/a/34291140/17708926，它部分地修复了这个问题，但是也在代码中引起了另一个错误。

这个问题的解决方案可以通过导出一个新的模型(如果它不存在的话)来获得，我知道在那个答案中这是相同的想法，但是现在它的实现方式不同了。

/// ... your schema


const model = mongoose.models.Model || mongoose.model("Model", modelSchema);


export default model;