Develop Reference

how to dynamically update one field in an array in mongoose schema [duplicate]

This question already has an answer here:
Update array element in mongo
(1 answer)
Closed 2 years ago.
I have the following array in my schema:
{
[...]
savedGames: [
{ name: "tutorial01", savedId: "ID0001" },
{ name: "tutorial02", savedId: "ID0001" },
{ name: "tutorial03", savedId: "ID0001" }
],
[...]
}
I would like to update the savedId field whenever it gets a new value. I have seen many topics using $ and arrayFilters but somehow I'm not able to figure out how to write it.
Could anyone please help me out how to write it properly?
[...]
const { id, savedId, name } = request.body;
await userSchema.findByIdAndUpdate({ _id: id }, ({ "$set": { "savedGames.$.savedId": savedId }}, { arrayFilters: [{ "savedGames.name": name }]}));
return response.json("Updated.");
[...]
Thanks in advance!
T

Is not very clear what's your expected output, but assuming you want to update the savedId field which match with values _id and name do you need something like this.
db.collection.update({
"_id": "1",
"files.name": "name1"
},
{
"$set": {
"files.$.savedId": "newId"
}
})
With this, you will get the subdocument you want matching _id and name.
After that, the $set operator will update the value.
Here is a mongo playground example
With mongoose you can use:
var updated = await model.updateOne({
_id: id,
"files.name": name
},{
$set:{
"files.$.savedId":savedId
}
})

Update query that handles duplicates and increment operator

Background:
I have an update query on collection called alerts that runs each
time a "flow" is received.
I have an array of objects in my alert's document called
blacklistedCommunication.
What should happen:
When a new flow arrives, then the alerts doc is updated only if the flow's client_addr and server_addr are not already present in blacklistedCommuication. While at the same time, if we do find duplicates, it should only increment the flowCount.
The current query:
The below update query works to push new objects to blacklistedCommunication object if it's not present already.
However, if it is indeed present, it will not update the flowCount
How can I incorporate this logic into the query? Do I need to write a separate update query in case of duplicates?
alerts.update({
alertLevel: "orgLevelAlert",
alertCategory: "blacklistedServersViolationAlert",
alertState: "open",
'blacklistedCommunication.client': {
$ne: flow.netflow.client_addr
},
// 'blacklistedCommunication.server': {
// $ne: flow.netflow.server_addr
// }
}, {
$set: {
"misc.updatedTime": new Date()
},
$inc: {
flowCount: 1
},
$push: {
blacklistedCommunication: {
client: flow.netflow.client_addr,
server: flow.netflow.server_addr
}
}
});

You can use $addToSet instead of $push. It will ensure unique {client:*,server:*} object within blacklistedCommunication and will always update flowCount:
alerts.update({
alertLevel: "orgLevelAlert",
alertCategory: "blacklistedServersViolationAlert",
alertState: "open"
}, {
$set: {
"misc.updatedTime": new Date()
},
$inc: {
flowCount: 1
},
$addToSet: {
blacklistedCommunication: {
client: flow.netflow.client_addr,
server: flow.netflow.server_addr
}
}
});

Mongoose: Add more items to existing object

Using Mongoose, How can I add more items to an object without replacing existing ones?
User.findOneAndUpdate(
{ userId: 0 },
{ userObjects: { newItem: value } }
);
The problem with above code is that it clears whatever was there before and replaces it with newItem when I wanted it just to add another item to userObjects(Like push function for javascript arrays).

Use dot notation to specify the field to update/add particular fields in an embedded document.
User.findOneAndUpdate(
{ userId: 0 },
{ "userObjects.newerItem": newervalue } }
);
or
User.findOneAndUpdate(
{ userId: 0 },
{ "$set":{"userObjects.newerItem": newervalue } }
);
or Use $mergeObjects aggregation operator to update the existing obj by passing new objects
User.findOneAndUpdate(
{"userId":0},
[{"$set":{
"userObjects":{
"$mergeObjects":[
"$userObjects",
{"newerItem":"newervalue","newestItem":"newestvalue"}
]
}
}}]
)

According to your question, i am guessing userObjects is an array.
You can try $push to insert items into the array.
User.findOneAndUpdate(
{ userId: 0 },
{ $push : {"userObjects": { newItem: value } }},
{safe :true , upsert : true},function(err,model)
{
...
});
For more info, read MongoDB $push reference.
Hope it helps you. If you had provided the schema, i could have helped better.

Just create new collection called UserObjects and do something like this.
UserObject.Insert({ userId: 0, newItem: value }, function(err,newObject){
});
Whenever you want to get these user objects from a user then you can do it using monogoose's query population to populate parent objects with related data in other collections. If not, then your best bet is to just make the userObjects an array.

Mongoose using where after populate [duplicate]

This question already has answers here:
Mongoose nested query on Model by field of its referenced model
(3 answers)
Closed 8 years ago.
I have a query that get user posts and I wish to show only the posts of the Country selected by visitor.
So far I'm trying to do something like this:
var country = req.query.country || req.session.country || { $ne: '' };
Posts.find({})
.populate('_creator')
.where('_creator.country').equals(country)
.exec(function(err, posts) {
console.log(posts);
});
Unfortunately it doesn't work.
How can I have a query similar to this?
EDIT:
This is the Posts Schema:
var postsSchema = new mongoose.Schema({
_creator: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
text: { type: String, default: '' },
created_at: Date
});

You can't include a populated field in your query because populate is executed as a separate query after the initial query completes.
One way to efficiently perform this type of query is to first look up the ids of the users of the selected country and then query for the posts from those users.
// Get the _ids of the users of the selected country.
User.find({country: country}, {_id: 1}, function(err, users) {
// Map the user docs into an array of just the _ids
var ids = users.map(function(user) { return user._id; });
// Get the posts whose _creator is in that set of ids
Post.find({_creator: {$in: ids}}).populate('_creator').exec(function(err, posts) {
// posts contains your answer
});
});

Mongoose find/update subdocument

I have the following schemas for the document Folder:
var permissionSchema = new Schema({
role: { type: String },
create_folders: { type: Boolean },
create_contents: { type: Boolean }
});
var folderSchema = new Schema({
name: { type: string },
permissions: [ permissionSchema ]
});
So, for each Page I can have many permissions. In my CMS there's a panel where I list all the folders and their permissions. The admin can edit a single permission and save it.
I could easily save the whole Folder document with its permissions array, where only one permission was modified. But I don't want to save all the document (the real schema has much more fields) so I did this:
savePermission: function (folderId, permission, callback) {
Folder.findOne({ _id: folderId }, function (err, data) {
var perm = _.findWhere(data.permissions, { _id: permission._id });
_.extend(perm, permission);
data.markModified("permissions");
data.save(callback);
});
}
but the problem is that perm is always undefined! I tried to "statically" fetch the permission in this way:
var perm = data.permissions[0];
and it works great, so the problem is that Underscore library is not able to query the permissions array. So I guess that there's a better (and workgin) way to get the subdocument of a fetched document.
Any idea?
P.S.: I solved checking each item in the data.permission array using a "for" loop and checking data.permissions[i]._id == permission._id but I'd like a smarter solution, I know there's one!

So as you note, the default in mongoose is that when you "embed" data in an array like this you get an _id value for each array entry as part of it's own sub-document properties. You can actually use this value in order to determine the index of the item which you intend to update. The MongoDB way of doing this is the positional $ operator variable, which holds the "matched" position in the array:
Folder.findOneAndUpdate(
{ "_id": folderId, "permissions._id": permission._id },
{
"$set": {
"permissions.$": permission
}
},
function(err,doc) {
}
);
That .findOneAndUpdate() method will return the modified document or otherwise you can just use .update() as a method if you don't need the document returned. The main parts are "matching" the element of the array to update and "identifying" that match with the positional $ as mentioned earlier.
Then of course you are using the $set operator so that only the elements you specify are actually sent "over the wire" to the server. You can take this further with "dot notation" and just specify the elements you actually want to update. As in:
Folder.findOneAndUpdate(
{ "_id": folderId, "permissions._id": permission._id },
{
"$set": {
"permissions.$.role": permission.role
}
},
function(err,doc) {
}
);
So this is the flexibility that MongoDB provides, where you can be very "targeted" in how you actually update a document.
What this does do however is "bypass" any logic you might have built into your "mongoose" schema, such as "validation" or other "pre-save hooks". That is because the "optimal" way is a MongoDB "feature" and how it is designed. Mongoose itself tries to be a "convenience" wrapper over this logic. But if you are prepared to take some control yourself, then the updates can be made in the most optimal way.
So where possible to do so, keep your data "embedded" and don't use referenced models. It allows the atomic update of both "parent" and "child" items in simple updates where you don't need to worry about concurrency. Probably is one of the reasons you should have selected MongoDB in the first place.

In order to validate subdocuments when updating in Mongoose, you have to 'load' it as a Schema object, and then Mongoose will automatically trigger validation and hooks.
const userSchema = new mongoose.Schema({
// ...
addresses: [addressSchema],
});
If you have an array of subdocuments, you can fetch the desired one with the id() method provided by Mongoose. Then you can update its fields individually, or if you want to update multiple fields at once then use the set() method.
User.findById(userId)
.then((user) => {
const address = user.addresses.id(addressId); // returns a matching subdocument
address.set(req.body); // updates the address while keeping its schema
// address.zipCode = req.body.zipCode; // individual fields can be set directly
return user.save(); // saves document with subdocuments and triggers validation
})
.then((user) => {
res.send({ user });
})
.catch(e => res.status(400).send(e));
Note that you don't really need the userId to find the User document, you can get it by searching for the one that has an address subdocument that matches addressId as follows:
User.findOne({
'addresses._id': addressId,
})
// .then() ... the same as the example above
Remember that in MongoDB the subdocument is saved only when the parent document is saved.
Read more on the topic on the official documentation.

If you don't want separate collection, just embed the permissionSchema into the folderSchema.
var folderSchema = new Schema({
name: { type: string },
permissions: [ {
role: { type: String },
create_folders: { type: Boolean },
create_contents: { type: Boolean }
} ]
});
If you need separate collections, this is the best approach:
You could have a Permission model:
var mongoose = require('mongoose');
var PermissionSchema = new Schema({
role: { type: String },
create_folders: { type: Boolean },
create_contents: { type: Boolean }
});
module.exports = mongoose.model('Permission', PermissionSchema);
And a Folder model with a reference to the permission document.
You can reference another schema like this:
var mongoose = require('mongoose');
var FolderSchema = new Schema({
name: { type: string },
permissions: [ { type: mongoose.Schema.Types.ObjectId, ref: 'Permission' } ]
});
module.exports = mongoose.model('Folder', FolderSchema);
And then call Folder.findOne().populate('permissions') to ask mongoose to populate the field permissions.
Now, the following:
savePermission: function (folderId, permission, callback) {
Folder.findOne({ _id: folderId }).populate('permissions').exec(function (err, data) {
var perm = _.findWhere(data.permissions, { _id: permission._id });
_.extend(perm, permission);
data.markModified("permissions");
data.save(callback);
});
}
The perm field will not be undefined (if the permission._id is actually in the permissions array), since it's been populated by Mongoose.

just try
let doc = await Folder.findOneAndUpdate(
{ "_id": folderId, "permissions._id": permission._id },
{ "permissions.$": permission},
);