Transactions in Mongoose

    If you haven’t already, import mongoose:

    To create a transaction, you first need to create a session using or Mongoose#startSession or .

    1. // Using Mongoose's default connection
    2. const session = await mongoose.startSession();
    4. // Using custom connection
    5. const db = await mongoose.createConnection(mongodbUri, { useUnifiedTopology: true, useNewUrlParser: true });
    6. const session = await db.startSession();
    • Creating a transaction
    • Committing the transaction if it succeeds
    • Aborting the transaction if your operation throws
    • Retrying in the event of a transient transaction error.

    For more information on the ClientSession#withTransaction() function, please see .

    Mongoose’s Connection#transaction() function is a wrapper around withTransaction() that integrates Mongoose change tracking with transactions. For example, the Connection#transaction() function handles resetting a document if you save() that document in a transaction that later fails.

    1. const schema = Schema({ name: String, arr: [String], arr2: [String] });
    3. const Test = db.model('Test', schema);
    5. await Test.createCollection();
    6. let doc = await Test.create({ name: 'foo', arr: ['bar'], arr2: ['foo'] });
    7. doc = await Test.findById(doc);
    8. await db.
    9.   transaction(async (session) => {
    10.     doc.arr.pull('bar');
    11.     doc.arr2.push('bar');
    13.     await doc.save({ session });
    14.     doc.name = 'baz';
    15.     throw new Error('Oops');
    16.   catch(err => {
    18.   });
    20. const changes = doc.getChanges();
    21. assert.equal(changes.$set.name, 'baz');
    22. assert.deepEqual(changes.$pullAll.arr, ['bar']);
    23. assert.deepEqual(changes.$push.arr2, { $each: ['bar'] });
    24. assert.ok(!changes.$set.arr2);
    26. await doc.save({ session: null });
    28. const newDoc = await Test.findById(doc);
    29. assert.equal(newDoc.name, 'baz');
    30. assert.deepEqual(newDoc.arr, []);
    31. assert.deepEqual(newDoc.arr2, ['foo', 'bar']);

    To get/set the session associated with a given document, use doc.$session().

    The Model.aggregate() function also supports transactions. Mongoose aggregations have a that sets the session option. Below is an example of executing an aggregation within a transaction.

    1. const Event = db.model('Event', new Schema({ createdAt: Date }), 'Event');
    2. const session = await db.startSession();
    4. await session.withTransaction(async () => {
    5.   await Event.insertMany([
    6.     { createdAt: new Date('2018-06-01') },
    7.     { createdAt: new Date('2018-06-02') },
    8.     { createdAt: new Date('2017-06-01') },
    9.     { createdAt: new Date('2017-05-31') }
    10.   ], { session: session });
    13.     {
    14.         _id: {
    15.           month: { $month: '$createdAt' },
    16.           year: { $year: '$createdAt' }
    17.         },
    18.         count: { $sum: 1 }
    19.       }
    20.     },
    21.     { $sort: { count: -1, '_id.year': -1, '_id.month': -1 } }
    22.   ]).session(session);
    24.   assert.deepEqual(res, [
    25.     { _id: { month: 6, year: 2018 }, count: 2 },
    26.     { _id: { month: 6, year: 2017 }, count: 1 },
    27.     { _id: { month: 5, year: 2017 }, count: 1 }
    28.   ]);
    29. });
    31. session.endSession();

    You can also use session.abortTransaction() to abort a transaction:

    1. const session = await Customer.startSession();
    2. session.startTransaction();
    4. await Customer.create([{ name: 'Test' }], { session: session });
    5. await Customer.create([{ name: 'Test2' }], { session: session });
    7. await session.abortTransaction();
    9. const count = await Customer.countDocuments();
    10. assert.strictEqual(count, 0);