MongoDB Command
The MongoDB Command step allows you to execute any MongoDB command using the db.command
method.
With this step, you can leverage the full power of MongoDB commands to interact with your MongoDB database. You can perform advanced operations, run aggregation pipelines, execute complex queries, and take advantage of specialized features specific to MongoDB.
Make sure to use MongoDB Extended JSON (v2) in your queries to prevent issues with complex data types (for example, UUID or Date).

MongoDB command examples
To run a MongoDB command, you simply need to select it in the Action selection dropdown and provide the necessary parameters. UI Bakery will then execute the command using the db.command
method behind the scenes.
In the example below, the find
command retrieves documents from the users collection where the age
field is greater than or equal to 30. The projection
parameter specifies that only the name
and age
fields should be included in the result.
{
find: "users",
filter: { age: { $gte: 30 } },
projection: { name: 1, age: 1 }
}
The Command Parameters field in this action step provides a familiar code editor interface allowing you to conveniently interact with the user interface and write JavaScript code, for example:
const minAge = +{{ui.input.value}}
return {
find: "users",
filter: { age: { $gte: minAge } },
projection: { name: 1, age: 1 }
}
Filter by Date
If the MongoDB Date property is of the BSON type, then in order to be able to filter by Date you should send not the date itself but rather an object with the key &date
inside the <, >, >e operators. Below is an example of the code you can use:
{
find: "orders",
filter: {
"created_at": {
$gte: {
$date: "2022-08-11T04:00:00+0400"
}
}
},
limit: 1000
}
Aggregate
To perform data aggregation, you can use the aggregate
operation with the following parameters:
{
aggregate: "users",
pipeline: [
{ $match: { age: { $gte: 30 } } },
{ $group: { _id: "$status", count: { $sum: 1 } } }
],
cursor: { batchSize: 10 }
}
In this example, the aggregation pipeline consists of several stages:
$match
to filter documents based on theage
field$group
to group documents by thestatus
field and calculate thecount
Join and aggregate
You can also use the aggregate
command in MongoDB to perform complex aggregations on your data by combining multiple stages in a pipeline:
{
aggregate: "users",
pipeline: [
{ $match: { age: { $gte: 30 } } },
{ $lookup: { from: "orders", localField: "_id", foreignField: "userId", as: "user_orders" } },
{ $unwind: "$user_orders" },
{ $group: { _id: "$_id", total_orders: { $sum: 1 }, total_amount: { $sum: "$user_orders.amount" } } },
{ $sort: { total_amount: -1 } },
{ $limit: 10 }
],
cursor: { batchSize: 10 }
}
In this query, we're performing the following operations:
$match
- Filters the documents to include only those where theage
is greater than or equal to 30.$lookup
- Joins the users collection with the orders collection based on the_id
field of users and theuserId
field of orders. This creates an array called user_orders containing the matching orders for each user.$unwind
- Deconstructs the user_orders array creating separate documents for each order associated with a user.$group
- Groups the documents by_id
(which is the unique identifier of the user) and calculates the total number of orders (total_orders
) and the total amount of orders (total_amount
) by summing up the amount field from the user_orders array.$sort
- Sorts the resulting documents in descending order based on thetotal_amount
field.$limit
- Limits the result to a maximum of 10 documents.
This query performs a join and aggregation operation to find users aged 30 or above, counts their total number of orders, calculates the total amount of their orders, and sorts the results by the total order amount in descending order. Finally, it limits the result to the top 10 users with the highest total order amount.
Insert multiple documents
To insert multiple documents into a collection, use the insertMany
command:
{
insert: "users",
documents: [
{ name: "John", age: 30 },
{ name: "Jane", age: 25 }
],
ordered: false
}
This example inserts two documents into the collection. Each document specifies the name
and age
fields.
The insert
command allows you to insert one or more documents into a collection. The ordered
option is set to false to continue inserting the remaining documents even if an error occurs for any individual document.
Update multiple documents
To update multiple documents in a collection, use the update
command:
{
update: "users",
updates: [
{ q: { age: { $gte: 30 } }, u: { $set: { status: "inactive" } }, multi: true }
]
}
This example updates all documents in the collection where the age
is greater or equal to 30. The $set
operator is used to set the status
field to inactive.
The update
command allows you to update one or more documents in a collection. The updates
array contains the update operations, where each operation has:
the
q
field for the query/filterthe
u
field for the updatethe
multi
field set to true to update multiple documents
Delete multiple documents
To delete multiple documents from a collection, use the delete
command:
{
delete: "users",
deletes: [
{ q: { status: "inactive" }, limit: 0 }
]
}
This example deletes all documents from the collection where the status
field is inactive
.
The delete
command allows you to delete one or more documents in a collection. The deletes
array contains the delete operations, where each operation has:
the
q
field for the query/filterthe
limit
field set to0
to delete all matching documents
Find one and modify
The findAndModify
command allows you to find a single document in your collection based on a filter condition and update it:
{
findAndModify: "users",
query: { name: "John" },
update: { $set: { name: "John Doe", age: 40 } },
new: true
}
This operation will find a document in the "users" table with the name
"John" and update its age
to 40 and name
to John Doe.
The findAndModify
command is used to atomically find and modify a document in a collection:
the
query
field specifies the filter for the document to findthe
update
field specifies the replacement documentthe
new
option set totrue
returns the modified document
Last updated
Was this helpful?