Mongoose, CastError: Cast to Array non è riuscito per il valore quando si tenta di salvare un modello che contiene un modello.

Question

Sto provando a creare il modello per il mio database mongodb usando mangusta. Questo è quello che sto cercando di fare:

var Class = mongoose.model('Class', {className: String, marks: [{type: Number}], grades: [{type: Number}]}); 
var User = mongoose.model('User', {email: String, classes: [Class] }); 


//Lets create a new user 
var class1 = new Class({className: 'aaa', marks: [72, 88, 63], grades: [30, 40, 30]}); 
var user1 = new User({email: 'aaa@some.com', classes: [class1]}); 

Salvataggio class1 sembra funzionare bene, ma quando controllo MongoDB, questo viene visualizzato: { "_id" : ObjectId("someId"), "className" : "TEST1234", "grades" : [ 30, 40, 30 ], "marks" : [ 72, 88, 63 ], "__v" : 0 }

cosa è "__v : 0"?

Salvare l'utente non è successo a tutti, questo è il seguente errore: ValidationError: CastError: Cast to Array failed for value "{ marks: [ 72, 88, 63 ], grades: [ 30, 40, 30 ], _id: someId, className: 'TEST1234' }" at path "classes"

Che cosa significa l'errore? Perché sta trasmettendo qualcosa a un array? classes: [Class] non dovrebbe essere una matrice di tipo class?

Answer 1

La definizione del modello non è corretta, è necessario correggere come di seguito.

// var Schema = mongoose.Schema; 
var User = mongoose.model('User',{ 
    email: String, 
    classes: [ {type: Schema.Types.ObjectID, ref: 'Class'}] 
}); 

var Class1 = new Class({/*yourDataWillBeHere*/}) 

Class1.save(function(err, classData) { 
    var User1 = new User({/*YourDataWillBeHere*/}) 
    User1.classes.push(classData._id); 
    User1.save(function(err, userData) { 
     //make something with userData object 
    }) 
}) 

quindi è possibile ottenere i dati recuperati utilizzando con populate() come questo

User 
.find() 
.populate('classes') 
.exec() 

Answer 2

provare a cambiare la definizione della classe a:

var classSchema = mongoose.Schema({className: String, marks: [{type: Number}], grades: [{type: Number}]}); 
var userSchema = mongoose.Schema({email: String, classes: [classSchema] }); 
var User = mongoose.model('User',userSchema); 

Ciò è necessario poiché mangusta non è in grado di analizzare il oggetto senza uno schema correlato. Ora quando crei un nuovo Schema per l'oggetto di classe interno e lo fai riferimento nella userSchema mango principale dovrebbe essere in grado di analizzare il tuo oggetto.

Answer 3

L'uomo, ho avuto un problema simile creando uno schema come questo:

QuestionnaireSchema = mongoose.Schema({ 
    formId: Number, 
    name: String, 
    questions: [ 
     { 
      type: String, 
      title: String, 
      alternatives:[{ 
       label: String, 
       value: "Mixed" 
      }] 
     } 
    ] 
}); 

mio errore è stato che sto usando "tipo" come un nome di campo e questo è riservata parola in mangusta.

mi limito a cambiare:

  type: String, 

a

  formType: String, 

e che funziona.

vedere: https://github.com/Automattic/mongoose/issues/1760

Answer 4

Per impostazione predefinita, se si dispone di un oggetto con chiave 'tipo' nello schema, mangusta lo interpreterà come una dichiarazione di tipo.

// Mongoose interprets this as 'loc is a String' 
var schema = new Schema({ loc: { type: String, coordinates: [Number] } }); 

Modifica della TypeKey:

var schema = new Schema({ 
    // Mongoose interpets this as 'loc is an object with 2 keys, type and coordinates' 
    loc: { type: String, coordinates: [Number] }, 
    // Mongoose interprets this as 'name is a String' 
    name: { $type: String } 
}, { typeKey: '$type' }); // A '$type' key means this object is a type declaration 

Link: http://mongoosejs.com/docs/guide.html#typeKey

Answer 5

Solo per Aggiornamento

Ora Mongoose supporta documenti secondari, che sono il modo documentato per gli array nido,

var arraySchema = new Schema({ 
    property: String 
}); 

var objectSchema = new Schema({ 
    arrays: [arraySchema] 
}); 

Fonti

http://mongoosejs.com/docs/schematypes.html

Answer 6

che definiscono in modo esplicito la regola tipo su una proprietà chiamata tipo è consentito e non genera un errore. in questo modo:

type: {type: String}