node.js - guide - node js server

Mapeo muchos a muchos con mangosta

Question

Tengo FlashcardSchemas y PackageSchemas en mi diseño. Una flashcard puede pertenecer a diferentes paquetes y un paquete puede contener diferentes tarjetas.

A continuación puede ver una versión simplificada de mis definiciones de esquema de mangosta:

// package-schema.js
var Schema = mongoose.Schema,
    ObjectId = Schema.ObjectId;

var PackageSchema = new Schema({
    id          : ObjectId,
    title       : { type: String, required: true },
    flashcards  : [ FlashcardSchema ]
});

var exports = module.exports = mongoose.model(''Package'', PackageSchema);

// flashcard-schema.js
var Schema = mongoose.Schema,
    ObjectId = Schema.ObjectId;

var FlashcardSchema = new Schema({
    id      : ObjectId,
    type        : { type: String, default: '''' },
    story       : { type: String, default: '''' },
    packages    : [ PackageSchema ]
});

var exports = module.exports = mongoose.model(''Flashcard'', FlashcardSchema);

Como puede ver en los comentarios anteriores, estas dos definiciones de esquema pertenecen a archivos separados y se referencian entre sí.

Recibo una excepción que indica que PackageSchema no está definido, como se esperaba. ¿Cómo puedo mapear una relación de muchos a muchos con la mangosta?

Answer 1

Estás pensando demasiado en esto como en una tienda de datos relacionales. Si eso es lo que quieres, usa MySQL (u otro RDBMS)

Si eso falla, entonces sí, se puede usar un tercer esquema, pero no olvide que solo será la identificación de cada objeto (no se une, recuerde) por lo que aún tendrá que recuperar cada elemento en una consulta separada .

Answer 2

Lo está haciendo de la manera correcta, sin embargo, el problema es que debe incluir PackageSchema en el flashcard-schema.js y viceversa. De lo contrario, estos archivos no tienen idea de lo que está haciendo referencia

var Schema = mongoose.Schema,
    ObjectId = Schema.ObjectId;
    PackageSchema = require(''./path/to/package-schema.js'')

var FlashcardSchema = new Schema({
    id      : ObjectId,
    type        : { type: String, default: '''' },
    story       : { type: String, default: '''' },
    packages    : [ PackageSchema ]
});

Answer 3

Soy nuevo en node, mongoDB y mangosta, pero creo que la forma correcta de hacerlo es:

var PackageSchema = new Schema({
    id: ObjectId,
    title: { type: String, required: true },
    flashcards: [ {type : mongoose.Schema.ObjectId, ref : ''Flashcard''} ]
});

var FlashcardSchema = new Schema({
    id: ObjectId,
    type: { type: String, default: '''' },
    story: { type: String, default: '''' },
    packages: [ {type : mongoose.Schema.ObjectId, ref : ''Package''} ]
});

De esta manera, solo almacena la referencia del objeto y no un objeto incrustado.

Answer 4

Puede utilizar el método Schema.add () para evitar el problema de referencia de reenvío.

Esta solución (no probada) coloca el esquema en un solo archivo .js

models / index.js

var Schema = mongoose.Schema,
    ObjectId = Schema.ObjectId;

// avoid forward referencing
var PackageSchema = new Schema();
var FlashcardSchema = new Schema();

PackageSchema.add({
    id          : ObjectId,
    title       : { type: String, required: true },
    flashcards  : [ FlashcardSchema ]
});

FlashcardSchema.add({
    id      : ObjectId,
    type        : { type: String, default: '''' },
    story       : { type: String, default: '''' },
    packages    : [ PackageSchema ]
});

// Exports both types
module.exports = {
    Package:   mongoose.model(''Package'', PackageSchema),
    Flashcard: mongoose.model(''Flashcard'', FlashcardSchema)
};  

Answer 5

https://www.npmjs.com/package/mongoose-relationship

##Many-To-Many with Multiple paths

var mongoose = require("mongoose"),
    Schema = mongoose.Schema,
    relationship = require("mongoose-relationship");

var ParentSchema = new Schema({
    children:[{ type:Schema.ObjectId, ref:"Child" }]
});
var Parent = mongoose.models("Parent", ParentSchema);

var OtherParentSchema = new Schema({
    children:[{ type:Schema.ObjectId, ref:"Child" }]
});
var OtherParent = mongoose.models("OtherParent", OtherParentSchema);

var ChildSchema = new Schema({
    parents: [{ type:Schema.ObjectId, ref:"Parent", childPath:"children" }]
    otherParents: [{ type:Schema.ObjectId, ref:"OtherParent", childPath:"children" }]
});
ChildSchema.plugin(relationship, { relationshipPathName:[''parents'', ''otherParents''] });
var Child = mongoose.models("Child", ChildSchema)

var parent = new Parent({});
parent.save();
var otherParent = new OtherParent({});
otherParent.save();

var child = new Child({});
child.parents.push(parent);
child.otherParents.push(otherParent);
child.save() //both parent and otherParent children property will now contain the child''s id 
child.remove()