Vielleicht ist es an der Zeit, vielleicht ertrinke ich in spärlicher Dokumentation und bin nicht in der Lage, mich mit dem Konzept der Aktualisierung in Mongoose zu beschäftigen :)

Das ist der Deal:

Ich habe ein Kontaktschema und ein Modell (verkürzte Eigenschaften):

var mongoose = require('mongoose'),
    Schema = mongoose.Schema;

var mongooseTypes = require("mongoose-types"),
    useTimestamps = mongooseTypes.useTimestamps;


var ContactSchema = new Schema({
    phone: {
        type: String,
        index: {
            unique: true,
            dropDups: true
        }
    },
    status: {
        type: String,
        lowercase: true,
        trim: true,
        default: 'on'
    }
});
ContactSchema.plugin(useTimestamps);
var Contact = mongoose.model('Contact', ContactSchema);

Ich erhalte vom Kunden eine Anfrage mit den Feldern, die ich benötige, und verwende mein Modell folgendermaßen:

mongoose.connect(connectionString);
var contact = new Contact({
    phone: request.phone,
    status: request.status
});

Und jetzt erreichen wir das Problem:

1. Wenn ich contact.save(function(err){...})anrufe, erhalte ich eine Fehlermeldung, wenn der Kontakt mit derselben Telefonnummer bereits vorhanden ist (wie erwartet - eindeutig).
2. Ich kann keinen update()Kontakt anrufen , da diese Methode in einem Dokument nicht vorhanden ist
3. Wenn ich update für das Modell aufrufe:
   Contact.update({phone:request.phone}, contact, {upsert: true}, function(err{...})
   Ich gerate in eine Endlosschleife, da die Implementierung des Mongoose-Updates eindeutig kein Objekt als zweiten Parameter haben möchte.
4. Wenn ich dasselbe mache, aber im zweiten Parameter ein assoziatives Array der Anforderungseigenschaften übergebe {status: request.status, phone: request.phone ...}, funktioniert es - aber dann habe ich keinen Verweis auf den spezifischen Kontakt und kann seine createdAtund updatedAtEigenschaften nicht herausfinden .

Nach dem Fazit habe ich also versucht: contactWenn ich ein Dokument gegeben habe , wie aktualisiere ich es, wenn es existiert, oder füge es hinzu, wenn es nicht existiert?

Vielen Dank für Ihre Zeit.

Mongoose unterstützt dies jetzt nativ mit findOneAndUpdate (ruft MongoDB findAndModify auf ).

Die Option upsert = true erstellt das Objekt, wenn es nicht vorhanden ist. Der Standardwert ist false .

var query = {'username': req.user.username};
req.newData.username = req.user.username;

MyModel.findOneAndUpdate(query, req.newData, {upsert: true}, function(err, doc) {
    if (err) return res.send(500, {error: err});
    return res.send('Succesfully saved.');
});

In älteren Versionen unterstützt Mongoose diese Hooks mit dieser Methode nicht:

• Standardeinstellungen
• Setter
• Validatoren
• Middleware

Ich habe gerade 3 Stunden lang gebrannt, um das gleiche Problem zu lösen. Insbesondere wollte ich das gesamte Dokument "ersetzen", falls vorhanden, oder es anderweitig einfügen. Hier ist die Lösung:

var contact = new Contact({
  phone: request.phone,
  status: request.status
});

// Convert the Model instance to a simple object using Model's 'toObject' function
// to prevent weirdness like infinite looping...
var upsertData = contact.toObject();

// Delete the _id property, otherwise Mongo will return a "Mod on _id not allowed" error
delete upsertData._id;

// Do the upsert, which works like this: If no Contact document exists with 
// _id = contact.id, then create a new doc using upsertData.
// Otherwise, update the existing doc with upsertData
Contact.update({_id: contact.id}, upsertData, {upsert: true}, function(err{...});

Ich habe auf der Mongoose-Projektseite ein Problem erstellt, bei dem angefordert wurde, dass Informationen dazu in die Dokumente aufgenommen werden.

Du warst nah dran

Contact.update({phone:request.phone}, contact, {upsert: true}, function(err){...})

Ihr zweiter Parameter sollte jedoch beispielsweise ein Objekt mit einem Änderungsoperator sein

Contact.update({phone:request.phone}, {$set: { phone: request.phone }}, {upsert: true}, function(err){...})

Nun, ich habe lange genug gewartet und keine Antwort erhalten. Schließlich gab der gesamte Update / Upsert-Ansatz auf und ging mit:

ContactSchema.findOne({phone: request.phone}, function(err, contact) {
    if(!err) {
        if(!contact) {
            contact = new ContactSchema();
            contact.phone = request.phone;
        }
        contact.status = request.status;
        contact.save(function(err) {
            if(!err) {
                console.log("contact " + contact.phone + " created at " + contact.createdAt + " updated at " + contact.updatedAt);
            }
            else {
                console.log("Error: could not save contact " + contact.phone);
            }
        });
    }
});

Funktioniert es? Ja. Bin ich damit zufrieden? Wahrscheinlich nicht. 2 DB-Aufrufe statt eines.
Hoffentlich würde eine zukünftige Implementierung von Mongoose eine Model.upsertFunktion haben.

Sehr elegante Lösung, die Sie mit der Kette von Versprechen erreichen können:

app.put('url', (req, res) => {

    const modelId = req.body.model_id;
    const newName = req.body.name;

    MyModel.findById(modelId).then((model) => {
        return Object.assign(model, {name: newName});
    }).then((model) => {
        return model.save();
    }).then((updatedModel) => {
        res.json({
            msg: 'model updated',
            updatedModel
        });
    }).catch((err) => {
        res.send(err);
    });
});

Ich bin der Betreuer von Mongoose. Die modernere Möglichkeit, ein Dokument zu aktualisieren, besteht darin, die Model.updateOne()Funktion zu verwenden .

await Contact.updateOne({
    phone: request.phone
}, { status: request.status }, { upsert: true });

Wenn Sie das aktualisierte Dokument benötigen, können Sie es verwenden Model.findOneAndUpdate()

const doc = await Contact.findOneAndUpdate({
    phone: request.phone
}, { status: request.status }, { upsert: true });

Der Schlüssel zum Erfolg ist, dass Sie die eindeutigen Eigenschaften des filterParameters in updateOne()oder findOneAndUpdate()und die anderen Eigenschaften des updateParameters einfügen müssen.

Hier ist ein Tutorial zum Upserting von Dokumenten mit Mongoose .

Ich habe NUR ein StackOverflow-Konto erstellt, um diese Frage zu beantworten. Nachdem ich die Interwebs erfolglos durchsucht hatte, schrieb ich selbst etwas. So habe ich es gemacht, damit es auf jedes Mungomodell angewendet werden kann. Importieren Sie diese Funktion entweder oder fügen Sie sie direkt in Ihren Code ein, in dem Sie die Aktualisierung durchführen.

function upsertObject (src, dest) {

  function recursiveFunc (src, dest) {
    _.forOwn(src, function (value, key) {
      if(_.isObject(value) && _.keys(value).length !== 0) {
        dest[key] = dest[key] || {};
        recursiveFunc(src[key], dest[key])
      } else if (_.isArray(src) && !_.isObject(src[key])) {
          dest.set(key, value);
      } else {
        dest[key] = value;
      }
    });
  }

  recursiveFunc(src, dest);

  return dest;
}

Um ein Mungo-Dokument zu verbessern, gehen Sie wie folgt vor:

YourModel.upsert = function (id, newData, callBack) {
  this.findById(id, function (err, oldData) {
    if(err) {
      callBack(err);
    } else {
      upsertObject(newData, oldData).save(callBack);
    }
  });
};

Diese Lösung erfordert möglicherweise 2 DB-Aufrufe, Sie profitieren jedoch von:

• Schemaüberprüfung für Ihr Modell, da Sie .save () verwenden
• Sie können tief verschachtelte Objekte ohne manuelle Aufzählung in Ihren Aktualisierungsaufruf einfügen. Wenn sich Ihr Modell ändert, müssen Sie sich also nicht um die Aktualisierung Ihres Codes kümmern

Denken Sie daran, dass das Zielobjekt die Quelle immer überschreibt, auch wenn die Quelle einen vorhandenen Wert hat

Wenn für Arrays das vorhandene Objekt ein längeres Array hat als das, das es ersetzt, bleiben die Werte am Ende des alten Arrays erhalten. Eine einfache Möglichkeit, das gesamte Array zu aktualisieren, besteht darin, das alte Array vor dem Upsert als leeres Array festzulegen, wenn Sie dies beabsichtigen.

UPDATE - 16.01.2016 Ich habe eine zusätzliche Bedingung hinzugefügt, denn wenn es ein Array primitiver Werte gibt, erkennt Mongoose nicht, dass das Array ohne Verwendung der Funktion "set" aktualisiert wird.

Ich musste ein Dokument aktualisieren / in eine Sammlung einfügen. Ich habe ein neues Objektliteral wie das folgende erstellt:

notificationObject = {
    user_id: user.user_id,
    feed: {
        feed_id: feed.feed_id,
        channel_id: feed.channel_id,
        feed_title: ''
    }
};

Besteht aus Daten, die ich von einer anderen Stelle in meiner Datenbank erhalte und dann die Aktualisierung des Modells aufrufe

Notification.update(notificationObject, notificationObject, {upsert: true}, function(err, num, n){
    if(err){
        throw err;
    }
    console.log(num, n);
});

Dies ist die Ausgabe, die ich bekomme, nachdem ich das Skript zum ersten Mal ausgeführt habe:

1 { updatedExisting: false,
    upserted: 5289267a861b659b6a00c638,
    n: 1,
    connectionId: 11,
    err: null,
    ok: 1 }

Und dies ist die Ausgabe, wenn ich das Skript zum zweiten Mal ausführe:

1 { updatedExisting: true, n: 1, connectionId: 18, err: null, ok: 1 }

Ich benutze Mungo Version 3.6.16

app.put('url', function(req, res) {

        // use our bear model to find the bear we want
        Bear.findById(req.params.bear_id, function(err, bear) {

            if (err)
                res.send(err);

            bear.name = req.body.name;  // update the bears info

            // save the bear
            bear.save(function(err) {
                if (err)
                    res.send(err);

                res.json({ message: 'Bear updated!' });
            });

        });
    });

Hier ist ein besserer Ansatz zur Lösung der Aktualisierungsmethode in Mungo. Weitere Informationen finden Sie in Scotch.io . Das hat definitiv bei mir funktioniert !!!

In 2.6 wurde ein Fehler eingeführt, der sich auch auf 2.7 auswirkt

Der Upsert funktionierte in 2.4 korrekt

https://groups.google.com/forum/#!topic/mongodb-user/UcKvx4p4hnY https://jira.mongodb.org/browse/SERVER-13843

Schauen Sie sich das an, es enthält einige wichtige Informationen

AKTUALISIERT:

Es bedeutet nicht, dass Upsert nicht funktioniert. Hier ist ein schönes Beispiel für die Verwendung:

User.findByIdAndUpdate(userId, {online: true, $setOnInsert: {username: username, friends: []}}, {upsert: true})
    .populate('friends')
    .exec(function (err, user) {
        if (err) throw err;
        console.log(user);

        // Emit load event

        socket.emit('load', user);
    });

Sie können den Datensatz einfach damit aktualisieren und die aktualisierten Daten als Antwort erhalten

router.patch('/:id', (req, res, next) => {
    const id = req.params.id;
    Product.findByIdAndUpdate(id, req.body, {
            new: true
        },
        function(err, model) {
            if (!err) {
                res.status(201).json({
                    data: model
                });
            } else {
                res.status(500).json({
                    message: "not found any relative data"
                })
            }
        });
});

das hat bei mir funktioniert.

app.put('/student/:id', (req, res) => {
    Student.findByIdAndUpdate(req.params.id, req.body, (err, user) => {
        if (err) {
            return res
                .status(500)
                .send({error: "unsuccessful"})
        };
        res.send({success: "success"});
    });

});

Hier ist der einfachste Weg zum Erstellen / Aktualisieren, während gleichzeitig die Middleware und die Validatoren aufgerufen werden.

Contact.findOne({ phone: request.phone }, (err, doc) => {
    const contact = (doc) ? doc.set(request) : new Contact(request);

    contact.save((saveErr, savedContact) => {
        if (saveErr) throw saveErr;
        console.log(savedContact);
    });
})

Für alle, die hier ankommen und noch nach einer guten Lösung für das "Upserting" mit Hakenunterstützung suchen, ist dies das, was ich getestet habe und arbeite. Es erfordert immer noch 2 DB-Aufrufe, ist aber viel stabiler als alles, was ich in einem einzelnen Aufruf versucht habe.

// Create or update a Person by unique email.
// @param person - a new or existing Person
function savePerson(person, done) {
  var fieldsToUpdate = ['name', 'phone', 'address'];

  Person.findOne({
    email: person.email
  }, function(err, toUpdate) {
    if (err) {
      done(err);
    }

    if (toUpdate) {
      // Mongoose object have extra properties, we can either omit those props
      // or specify which ones we want to update.  I chose to update the ones I know exist
      // to avoid breaking things if Mongoose objects change in the future.
      _.merge(toUpdate, _.pick(person, fieldsToUpdate));
    } else {      
      toUpdate = person;
    }

    toUpdate.save(function(err, updated, numberAffected) {
      if (err) {
        done(err);
      }

      done(null, updated, numberAffected);
    });
  });
}

Wenn Generatoren verfügbar sind, wird es noch einfacher:

var query = {'username':this.req.user.username};
this.req.newData.username = this.req.user.username;
this.body = yield MyModel.findOneAndUpdate(query, this.req.newData).exec();

Bei mir hat keine andere Lösung funktioniert. Ich verwende eine Post-Anfrage und aktualisiere Daten, wenn sie gefunden werden. Andernfalls füge sie ein. Außerdem wird _id mit dem Anfragetext gesendet, der entfernt werden muss.

router.post('/user/createOrUpdate', function(req,res){
    var request_data = req.body;
    var userModel = new User(request_data);
    var upsertData = userModel.toObject();
    delete upsertData._id;

    var currentUserId;
    if (request_data._id || request_data._id !== '') {
        currentUserId = new mongoose.mongo.ObjectId(request_data._id);
    } else {
        currentUserId = new mongoose.mongo.ObjectId();
    }

    User.update({_id: currentUserId}, upsertData, {upsert: true},
        function (err) {
            if (err) throw err;
        }
    );
    res.redirect('/home');

});

//Here is my code to it... work like ninj

router.param('contractor', function(req, res, next, id) {
  var query = Contractors.findById(id);

  query.exec(function (err, contractor){
    if (err) { return next(err); }
    if (!contractor) { return next(new Error("can't find contractor")); }

    req.contractor = contractor;
    return next();
  });
});

router.get('/contractors/:contractor/save', function(req, res, next) {

    contractor = req.contractor ;
    contractor.update({'_id':contractor._id},{upsert: true},function(err,contractor){
       if(err){ 
            res.json(err);
            return next(); 
            }
    return res.json(contractor); 
  });
});


--

User.findByIdAndUpdate(req.param('userId'), req.body, (err, user) => {
    if(err) return res.json(err);

    res.json({ success: true });
});

Nach der Antwort von Travelling Tech Guy , die bereits großartig ist, können wir ein Plugin erstellen und es an Mungo anhängen, sobald wir es so initialisiert haben .upsert() damit es für alle Modelle verfügbar ist.

plugins.js

export default (schema, options) => {
  schema.statics.upsert = async function(query, data) {
    let record = await this.findOne(query)
    if (!record) {
      record = new this(data)
    } else {
      Object.keys(data).forEach(k => {
        record[k] = data[k]
      })
    }
    return await record.save()
  }
}

db.js

import mongoose from 'mongoose'

import Plugins from './plugins'

mongoose.connect({ ... })
mongoose.plugin(Plugins)

export default mongoose

Dann können Sie so etwas tun User.upsert({ _id: 1 }, { foo: 'bar' })oder YouModel.upsert({ bar: 'foo' }, { value: 1 })wann immer Sie wollen.

Ich bin gerade nach einer Weile auf dieses Problem zurückgekommen und habe beschlossen, ein Plugin zu veröffentlichen, das auf der Antwort von Aaron Mast basiert.

https://www.npmjs.com/package/mongoose-recursive-upsert

Verwenden Sie es als Mungo-Plugin. Es wird eine statische Methode eingerichtet, mit der das übergebene Objekt rekursiv zusammengeführt wird.

Model.upsert({unique: 'value'}, updateObject});

Dieses Coffeescript funktioniert für mich mit Node - der Trick besteht darin, dass die _id beim Senden und Zurückgeben vom Client vom ObjectID-Wrapper befreit wird und daher für Updates ersetzt werden muss (wenn keine _id angegeben ist, wird save zum Einfügen und Hinzufügen zurückgesetzt einer).

app.post '/new', (req, res) ->
    # post data becomes .query
    data = req.query
    coll = db.collection 'restos'
    data._id = ObjectID(data._id) if data._id

    coll.save data, {safe:true}, (err, result) ->
        console.log("error: "+err) if err
        return res.send 500, err if err

        console.log(result)
        return res.send 200, JSON.stringify result

um auf dem aufzubauen, was Martin Kuzdowicz oben gepostet hat. Ich verwende das Folgende, um ein Update mit Mungo und einer tiefen Zusammenführung von JSON-Objekten durchzuführen. Zusammen mit der Funktion model.save () in mongoose ermöglicht dies mongoose eine vollständige Validierung, selbst wenn diese auf anderen Werten im json beruht. Es erfordert das Deepmerge-Paket https://www.npmjs.com/package/deepmerge . Aber das ist ein sehr leichtes Paket.

var merge = require('deepmerge');

app.put('url', (req, res) => {

    const modelId = req.body.model_id;

    MyModel.findById(modelId).then((model) => {
        return Object.assign(model, merge(model.toObject(), req.body));
    }).then((model) => {
        return model.save();
    }).then((updatedModel) => {
        res.json({
            msg: 'model updated',
            updatedModel
        });
    }).catch((err) => {
        res.send(err);
    });
});

Nachdem ich die obigen Beiträge gelesen hatte, entschied ich mich, diesen Code zu verwenden:

    itemModel.findOne({'pid':obj.pid},function(e,r){
        if(r!=null)
        {
             itemModel.update({'pid':obj.pid},obj,{upsert:true},cb);
        }
        else
        {
            var item=new itemModel(obj);
            item.save(cb);
        }
    });

Wenn r null ist, erstellen wir ein neues Element. Verwenden Sie andernfalls upsert in update, da durch update kein neues Element erstellt wird.