Mongoose.js: aggiornamento atomico delle proprietà annidate?

Question

Utilizzando Mongoose versione 3.6.4

dire che ho un documento MongoDB in questo modo:

{ 
    "_id" : "5187b74e66ee9af96c39d3d6", 
    "profile" : { 
     "name" : { 
      "first" : "Joe", 
      "last" : "Pesci", 
      "middle" : "Frank" 
     } 
    } 
} 

e ho il seguente schema per gli utenti:

var UserSchema = new mongoose.Schema({ 
    _id: { type: String }, 
    email: { type: String, required: true, index: { unique: true }}, 
    active: { type: Boolean, required: true, 'default': false }, 
    profile: { 
    name: { 
     first: { type: String, required: true }, 
     last:  { type: String, required: true }, 
     middle: { type: String } 
    } 
    } 
    created: { type: Date, required: true, 'default': Date.now}, 
    updated: { type: Date, required: true, 'default': Date.now} 
); 

E io presentare un modulo di passaggio un campo denominato: profile[name][first] con un valore di Joseph

e quindi voglio aggiornare solo l'utente fi primo nome, ma lascia il suo ultimo e mezzo da solo, ho pensato di fare solo:

User.update({email: "joe@foo.com"}, req.body, function(err, result){}); 

Ma quando faccio questo, "cancella" le proprietà profile.name.last e profile.name.middle e io alla fine con un documento che sembra :

{ 
    "_id" : "5187b74e66ee9af96c39d3d6", 
    "profile" : { 
     "name" : { 
      "first" : "Joseph" 
     } 
    } 
} 

quindi è praticamente sovrascrivere tutti profile con req.body.profile, che credo abbia senso. C'è un modo per aggirarlo senza dover essere più esplicito specificando i miei campi nella query di aggiornamento invece di req.body?

Answer 1

Lei ha ragione, Mongoose converte aggiornamenti $set per voi. Ma questo non risolve il tuo problema. Provalo nella shell di mongodb e vedrai lo stesso comportamento.

Invece, per aggiornare una singola proprietà profondamente nidificata è necessario specificare il percorso completo della proprietà deep nello $set.

User.update({ email: 'joe@foo.com' }, { 'profile.name.first': 'Joseph' }, callback) 

Answer 2

Penso che si sta cercando $ set

http://docs.mongodb.org/manual/reference/operator/set/

User.update({email: "joe@foo.com"}, { $set : req.body}, function(err, result){}); 

Prova che

Answer 3

Forse è una buona soluzione - aggiunge opzione per Model.update, che sostituiscono gli oggetti nidificati come:

{field1: 1, fields2: {a: 1, b: 2}} => { 'field1': 1, 'field2.a': 1, 'field2.b': 2}

nestedToDotNotation: function(obj, keyPrefix) { 
    var result; 
    if (keyPrefix == null) { 
     keyPrefix = ''; 
    } 
    result = {}; 
    _.each(obj, function(value, key) { 
     var nestedObj, result_key; 
     result_key = keyPrefix + key; 
     if (!_.isArray(value) && _.isObject(value)) { 
     result_key += '.'; 
     nestedObj = module.exports.nestedToDotNotation(value, result_key); 
     return _.extend(result, nestedObj); 
     } else { 
     return result[result_key] = value; 
     } 
    }); 
    return result; 
    } 

});

bisogno miglioramenti movimentazione riferimento circolare, ma questo è molto utile quando si lavora con oggetti nidificati

sto usando sottolineatura.js qui, ma queste funzioni facilmente possono essere sostituiti con altri analoghi

Answer 4

Uno molto facile modo per risolvere questo con Moongose 4.1 e il pacchetto flat:

var flat = require('flat'), 
    Schema = mongoose.Schema, 
     schema = new Schema(
      { 
       name: { 
        first: { 
         type: String, 
         trim: true 
        }, 
        last: { 
         type: String, 
         trim: true 
        } 
       } 
      } 
     ); 

    schema.pre('findOneAndUpdate', function() { 
     this._update = flat(this._update); 
    }); 


    mongoose.model('User', schema); 

req.body (per esempio) può ora essere:

{ 
    name: { 
     first: 'updatedFirstName' 
    } 
} 

L'oggetto verrà appiattito prima dell'esecuzione della query effettiva, pertanto $set aggiornerà solo le proprietà previste anziché l'intero oggetto name.