Wie aktualisiere / aktualisiere ich ein Dokument in Mongoose?

367

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.

Travelling Tech Guy
quelle
Was ist in der Einhaken prefür save?
Shamoon

Antworten:

427

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
Pascalius
quelle
17
Dies sollte die aktuelle Antwort sein. Die meisten anderen verwenden zwei Anrufe oder (glaube ich) greifen auf den nativen Mongodb-Treiber zurück.
Huggie
10
Das Problem mit findOneAndUpdate ist, dass das Pre-Save nicht ausgeführt wird.
a77icu5
2
Klingt nach einem Fehler in Mongoose oder MongoDB?
Pascalius
8
Aus der Dokumentation: „... wenn die findAndModify Helfer verwendet wird , werden die folgenden nicht angewendet: defaults, Einrichter, Validierer, Middleware“ mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
Kellen
2
@ JamieHutber Dies ist nicht standardmäßig festgelegt, es ist eine benutzerdefinierte Eigenschaft
Pascalius
194

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.

Clint Harris
quelle
1
Die Dokumentation scheint im Moment schlecht zu sein. Es gibt einige in den API-Dokumenten (Suche nach "Update" auf der Seite. Sieht so aus: MyModel.update({ age: { $gt: 18 } }, { oldEnough: true }, fn);undMyModel.update({ name: 'Tobi' }, { ferret: true }, { multi: true }, fn);
CpILL
für das Falldokument wird nicht gefunden, welche _id wird verwendet? Mungo erzeugt es oder das, gegen das abgefragt wurde?
Haider
91

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){...})
Chrixian
quelle
15
Ich glaube nicht, dass Sie den {$set: ... }Teil hier als seine automatische Form meiner Lektüre
brauchen
5
Ja, Mungo sagt, es verwandelt alles in $ set
grantwparks
1
Dies war zum Zeitpunkt des Schreibens gültig. Ich verwende MongoDB nicht mehr, daher kann ich in den letzten Monaten nicht mehr mit Änderungen sprechen: D
chrixian
5
Wenn Sie von Zeit zu Zeit den nativen Treiber verwenden, ist es möglicherweise eine schlechte Angewohnheit, $ set nicht zu verwenden.
UpTheCreek
Sie können $ set und $ setOnInsert verwenden, um im Fall einer Einfügung nur bestimmte Felder
festzulegen
73

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.

Travelling Tech Guy
quelle
2
In diesem Beispiel wird die in MongoDB 2.2 hinzugefügte Schnittstelle verwendet, um die Optionen multi und upsert in einem Dokumentformular anzugeben. .. include :: /includes/fact-upsert-multi-options.rst In der Dokumentation heißt es, ich weiß nicht, wohin ich von hier aus gehen soll.
Donald Derek
1
Obwohl dies funktionieren sollte, führen Sie jetzt 2 Operationen (Suchen, Aktualisieren) aus, wenn nur 1 (Upsert) benötigt wird. @chrixian zeigt den richtigen Weg, dies zu tun.
RespektTheCode
12
Es ist erwähnenswert, dass dies die einzige Antwort ist, mit der die Validatoren von Mongoose aktiv werden können. Gemäß den Dokumenten erfolgt keine Validierung, wenn Sie update aufrufen.
Tom Spencer
@fiznool sieht so aus, als könnten Sie die Option runValidators: truewährend eines Updates manuell übergeben : Update-Dokumente (Update-Validatoren werden jedoch nur ausgeführt $setund $unsetVorgänge ausgeführt)
Danny
Siehe meine Antwort basierend auf dieser, wenn Sie .upsert()für alle Modelle verfügbar sein müssen. stackoverflow.com/a/50208331/1586406
spondbob
24

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);
    });
});
Martin Kuzdowicz
quelle
Warum wurde dies nicht positiv bewertet? Scheint eine großartige Lösung und sehr elegant
MadOgre
Die brillante Lösung hat mich dazu gebracht, meine Herangehensweise an Versprechen zu überdenken.
Lux
4
Noch eleganter wäre es, (model) => { return model.save(); }als model => model.save()und auch (err) => { res.send(err); }als umzuschreiben err => res.send(err);)
Jeremy Thille
1
Wo kann ich weitere Informationen erhalten?
V0LT3RR4
17

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 .

vkarpov15
quelle
15

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.

Aaron Mast
quelle
2
+1 für die Erstellung von acc nur dafür: P Ich wünschte, ich könnte eine weitere +1 nur für die Verwendung von .save () geben, da findOneAndUpate () dazu führt, dass wir keine Validatoren und Pre-, Post- usw. verwenden können. Danke, ich werde das auch überprüfen
user1576978
Entschuldigung, aber es hat hier nicht funktioniert :( Ich habe die Größe des Aufrufstapels überschritten
user1576978
Welche Version von lodash verwenden Sie? Ich benutze lodash Version 2.4.1 Danke!
Aaron Mast
Wie komplex sind die Objekte, die Sie stören? Wenn sie zu groß sind, kann der Knotenprozess möglicherweise nicht die Anzahl der rekursiven Aufrufe verarbeiten, die zum Zusammenführen der Objekte erforderlich sind.
Aaron Mast
Ich habe dies verwendet, musste aber die Schutzbedingung hinzufügen if(_.isObject(value) && _.keys(value).length !== 0) {, um den Stapelüberlauf zu stoppen. Lodash 4+ hier scheint es, Nicht-Objektwerte in Objekte im keysAufruf umzuwandeln , so dass rekursiver Schutz immer wahr war. Vielleicht gibt es einen besseren Weg, aber es funktioniert jetzt fast für mich ...
Richard G
12

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

andres_gcarmona
quelle
10
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 !!!

Eyo Okon Eyo
quelle
5
Es ist ein Fehler zu glauben, dass dies dasselbe tut wie das Update von MongoDB. Es ist nicht atomar.
Valentin Waeselynck
1
Ich möchte die Antwort von @ValentinWaeselynck sichern. Scotchs Code ist sauber - aber Sie holen ein Dokument und aktualisieren es dann. In der Mitte dieses Prozesses könnte das Dokument geändert werden.
Nick Pineda
8

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);
    });
Hilfe
quelle
7

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"
                })
            }
        });
});
Muhammad Awais
quelle
6

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"});
    });

});

Emmanuel Ndukwe
quelle
Vielen Dank. Dies war derjenige, der endlich für mich funktioniert hat!
Luis Febro
4

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);
    });
})
Mindest
quelle
3

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);
    });
  });
}
Terry
quelle
3

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();
Blacksonic
quelle
3

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');

});
Priyanshu Chauhan
quelle
2
//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); 
  });
});


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

    res.json({ success: true });
});
Zeeshan Ahmad
quelle
Dieses Code-Snippet kann das Problem zwar lösen, erklärt jedoch nicht, warum oder wie es die Frage beantwortet. Bitte geben Sie eine Erklärung für Ihren Code an , da dies wirklich zur Verbesserung der Qualität Ihres Beitrags beiträgt. Denken Sie daran, dass Sie die Frage für Leser in Zukunft beantworten und diese Personen möglicherweise die Gründe für Ihren Codevorschlag nicht kennen. Flagger / Rezensenten: Für Nur-Code-Antworten wie diese, Downvote, nicht löschen!
Patrick
2

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.

Spondbob
quelle
2

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});
Richard G.
quelle
0

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
Simon H.
quelle
0

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);
    });
});
Chris Deleo
quelle
1
Ich würde req.bodyvor dem Testen auf NoSQL-Injection davor warnen , wie sie ist zu verwenden (siehe owasp.org/index.php/Testing_for_NoSQL_injection ).
Travelling Tech Guy
1
@TravelingTechGuy Danke für die Vorsicht, ich bin noch neu bei Node und Mongoose. Wäre mein Mungo-Modell mit Validatoren nicht genug, um einen Injektionsversuch zu erwischen? während der model.save ()
Chris Deleo
-5

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.

Grant Li
quelle
Wenn es zwei Anrufe bei Mongo sind, ist es nicht wirklich ärgerlich, oder?
Huggie