MissingSchemaError: Schema is niet geregistreerd voor model “Gebruiker”

In mijn bestand models/user.js:

var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var userSchema = new Schema({
    (define schema)
});
...
(save user)
...
(check password)
...
mongoose.model('User', userSchema);

En in mijn router/index.jsheb ik:

var mongoose = require('mongoose');
var User = mongoose.model('User');

die de fout veroorzaakt:

MissingSchemaError: Schema hasn't been registered for model "User".

Als ik dat echter in user.jswel doe (in de laatste regel)

module.exports = mongoose.model('User', userSchema);

en in index.jsdoe ik var User = require('../models/User');, dan werkt alles.

Maar dat zou niet moeten, want in config/pass.jsdoe ik var User = mongoose.model('User');en het werkt feilloos.

De require('../models/User');syntaxis werkt niet op Ubuntu, maar wel op mijn Mac.

Wat moet ik doen? Hoe repareer ik het? Ik heb talloze voorbeeld-apps bekeken, waaronder MEAN, maar niets was echt nuttig .

Antwoord 1, autoriteit 100%

Ik kreeg hetzelfde probleem toen ik de MEAN-zelfstudie probeerde.

Na wat onderzoek te hebben gedaan, ontdekte ik dat in app.js, als ik required(“./models/User”) voor var routes = required(“./routes/index”) plaats, dan werkt het.

Zoals dit:

mongoose.connect("mongodb://localhost/news");
require("./models/Posts");
require("./models/Comments");
var routes = require('./routes/index');
var users = require('./routes/users');
var app = express();

Ik hoop dat het antwoord nuttig zal zijn!

Antwoord 2, autoriteit 59%

De fout treedt op omdat models/user.jsniet is geïnterpreteerd op het moment dat router/index.jsis geladen. Een manier om dit op te lossen is door het volgende te doen:

var mongoose = require('mongoose');
//Load all your models
var User = require('./../models/user.js');
//Now, this call won't fail because User has been added as a schema.
mongoose.model('User');

Dit blijkt echter tegen de beste praktijken in te gaan, die dicteren dat al deze configuratie-dingen aan het begin van je app.js-bestand moeten gebeuren. Bekijk dit voorbeeld van het voorbeeldproject van madhums

var models_path = __dirname + '/app/models'
fs.readdirSync(models_path).forEach(function (file) {
  if (~file.indexOf('.js')) require(models_path + '/' + file)
})

Houd er rekening mee dat hij zijn modellen laadt voordat hij de router van de app instelt.
Wat betreft het Ubuntu vs Mac-probleem, ik denk dat dit komt omdat een relatief pad in Ubuntu moet beginnen met ./. Je hoeft het alleen maar te veranderen in ./../models/user.js, wat werkt op Mac.

Antwoord 3, autoriteit 14%

Alle code in de js-bestanden van uw mangoestschema had moeten zijn uitgevoerd voordat deze in andere bestanden wordt gebruikt.

Het volgende codefragment bijvoorbeeld zorgt ervoor dat de mangoestige schemebestanden / -modules worden uitgevoerd.

FS.readdirsync (__ dirname + ‘/App/models’).forach (bestand) {
if (~ file.indexof (‘. JS’)) vereisen (__ Dirname + ‘/ app / modellen /’ + bestand); });

of schema-bestanden kunnen handmatig worden uitgevoerd door

te bellen

Var-gebruiker = vereisen (‘./ app / modellen / user.js’)

Voordat de modellen overal in de toepassing worden gebruikt.

Nadat het bovenstaande is gedaan, kunnen andere modules die Mongoose-modellen gebruiken, vereist / uitgevoerd.

Antwoord 4, Autoriteit 9%

Dit probleem heeft plaatsgevonden bij het proberen om het modelbestandslading

te laden

Ik heb hetzelfde probleem opgelost in mijn gemiddelde.io project

in de controller:

'use strict';
require('../models/settingsModel'); // load settingsModel.js file before get mongoose.model('Settings')
var mongoose = require('mongoose'),
    Settings = mongoose.model('Settings'),
    Q = require('q');

Antwoord 5, Autoriteit 6%

In mijn geval gebeurde het vanwege de verwarring van kapitaal / kleine letter.
Gebruikersmodel had dit:

const userSchema = new Schema({
// ...
});
module.exports = mongoose.model('User', userSchema);

en het productmodel had een verwijzing naar het gebruikersmodel, maar kleine case:

const productSchema = new Schema({
// ...
  userId: {
    type: Schema.Types.ObjectId,
    ref: 'user', // This should exactly match the name of User model above!!!
    required: true
  }
});

Antwoord 6, Autoriteit 4%

Ik heb deze fout ook ervaren met ES6/Typescript. Zelfs ik heb het model geïmporteerd, de fout bleef bestaan. Volgens documenten hier

MongooseError.MissingSchemaError

Gegooid wanneer u probeert toegang te krijgen tot een model dat nog niet is geregistreerd

   import { model, Schema } from 'mongoose';
    import Company from './CompanyModel';
    const ProjectSchema = new Schema({
        company: { type: Schema.Types.ObjectId, ref: "Company" }
    });
    export default model('Project', ProjectSchema);

De tips waren alleen om ervoor te zorgen dat het model expliciet werd gebruikt, dus het veranderen van ref:"Company"in ref:Company.modelNameleek het te verhelpen.

>

Ik hoop dat sommigen van jullie er wat aan hebben

Antwoord 7, autoriteit 4%

• U moet uw model in uw code opnemen
• Mongoose herkent pas dat je een model hebt gedefinieerd als je mongoose.model hebt gebeld, en dat wordt alleen aangeroepen als je een model nodig hebt

Bijvoorbeeld.

In het onderstaande voorbeeld krijgt u MissingSchemaError: Schema hasn't been registered for model “Role”als u const Role = require("./role");

const mongoose = require("mongoose");
const Schema = mongoose.Schema;
const Role = require("./role");
const userSchema = new Schema(
  {
    role: { type: Schema.Types.ObjectId, ref: "Role", required: false },
    username: { type: String, required: true, trim: true },
    password: { type: String, required: true, trim: true },
    email: { type: String, required: true, trim: true }
  },
  { timestamps: true }
);
module.exports = mongoose.model("User", userSchema);

Antwoord 8, autoriteit 4%

Ik heb letterlijk veel onderzoek gedaan en ik heb een oplossing gevonden, dus ik deel deze oplossing met je, zodat niemand die goedkope fout kan maken die ik heb gemaakt.

Houd er rekening mee dat u dezelfde naam in refhoeft toe te voegen die u in uw modelhebt opgegeven, omdat deze hoofdlettergevoelig is ( Product !== product ).

p>

const Product = new mongoose.model(‘Product’, productSchema);

product: {
    type: mongoose.Schema.ObjectId,
    ref: 'Product', <-- Should be same as modelName
    required: [true, 'Cart must belong to a product']
}

Antwoord 9, autoriteit 3%

Bij het gebruik van express is een van de veelgemaakte fouten dat de express voor mangoest wordt vereist. Dit resulteert in “MissingSchemaError: Schema is niet geregistreerd voor model “User”.” fout.

Je kunt het gemakkelijk oplossen door de “vereiste” volgorde te corrigeren (d.w.z. mangoest en dan express)

var mongoose = require('./config/mongoose'), 
    express = require('./config/express');

Antwoord 10

Ik kreeg deze foutmelding toen ik mongoose-fixtureprobeerde te gebruiken om een aantal standaardgegevens in een mongo-verzameling te plaatsen. Was lang verbijsterd, volgde deze en soortgelijke threads voor hulp, probeerde te debuggen. Uiteindelijk bleek het probleem in mijn geval te wijten te zijn aan de versies mongooseen mongoose-fixture.

Als geen codewijzigingen helpen, of als je deze foutmelding krijgt terwijl je probeert om mongoose-fixturecorrect te gebruiken (die verondersteld wordt je schema’s voor je te registreren), probeer dit dan. Verwijder de node_modulesmap van je project, voer een npm cache cleanuit en vervolgens een npm install.

Als zelfs dit niet helpt, probeer dan versies van mongoose/ mongoose-fixturete vergelijken tussen de problematische app en een die werkt, en probeer de versie in uw package.jsonen herhaal de bovenstaande stappen. Dit werkte voor mij.

Antwoord 11

Ik kwam onlangs een oplossing tegen die lijkt op de antwoorden van @rajkumar-nagarajan en @verybadalloc.

Ik vind deze aanpak beter, omdat het de n+1-iteratie vermijdt en niet alle modellen uit het bestandssysteem leest.

In app/models/index.jsvereist elk modelbestand:

require('./model1');
require('./model2');
require('./model3');

Vervolgens, in /app.jsof /index.js(wat je project ook gebruikt), kun je nu eenvoudig het volgende doen:

require('./app/models');

Het deel dat ik mis (tips worden hier gewaardeerd) –hoe elk model gemakkelijk op naam te registreren, zoals:

mongoose.model('Model1')

Antwoord 12

Ik maakte een andere fout, zoals ik het schema had gemaakt, maar het probleem was dat ik geen schemamodel gebruikte (voor het invoegen, bijwerken, lezen en verwijderen van het document).

d.w.z. Ik heb de collectie ongeveer zo gemaakt:

const playerSchema = new Schema({
    bowling: {
        style: String,
        arm: String,
    }
})
export const PlayerSchema = model('Player', playerSchema)

maar heb het model PlayerSchemaniet ergens gebruikt of aangeroepen, daarom kreeg ik deze foutmelding.

Antwoord 13

Ik kwam dit probleem tegen toen ik probeerde een nieuw model toe te voegen aan de basiscode van deze tutorial Gebruikersverificatie op MEAN-stack. De oplossing is zoals Aheizei.

In het bijzonder moet ik een regel require('path/to/your/model')toevoegen aan het einde van /app_api/models/db.jsdie is vereist in de app.js. Het is beter om de consistentie van de structuur te behouden voor het gemak van ontwikkeling.

Antwoord 14

Ik heb alle bovenstaande oplossingen geprobeerd, maar ze faalden allemaal. Ik ontdekte dat de oplossing was om mijn database (MongoDB) te wissen en vervolgens de app opnieuw uit te voeren

Antwoord 15

Het probleem doet zich voor in de require()-instructies voor de modellen. U moet alle MongoDB-afhankelijkheden boven de route-afhankelijkheden zoals deze verplaatsen, bijvoorbeeld

//blog.js file
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const blogSchema = new Schema({
title : String
});
mongoose.model('blogs', blogSchema);

in server.js

//server.js file
require('dotenv').config();
const mongoose = require('mongoose');
const express = require('express');
const bodyParser = require('body-parser');
const cors = require('cors');
require('./models/blog');
const Blog = mongoose.model('blogs');
const URL = process.env.MONGO_DB_URL;
 mongoose.connect(URL, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});
mongoose.connection
.once('open', () => console.log('Connected to MongoLab instance.'))
.on('error', (error) => console.log('Error connecting to MongoLab:', error));
const app = express();
app.use(cors());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.get('/',  (req,res)=>{
res.send('Hello World')
});
 app.post('/blog',async (req, res) =>{
    const blog = await new Blog(req.body).save();
    res.send('just an example');
  });

Antwoord 16

Als je de Mean.js-stack gebruikt, voer je de test uit met:

grunt test

En niet met

mocha