@toa.io/storages.mongodb 1.0.0-alpha.320 → 1.0.0-alpha.322

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.0.0-alpha.322](https://github.com/toa-io/toa/compare/v1.0.0-alpha.321...v1.0.0-alpha.322) (2026-09-29)
+
+**Note:** Version bump only for package @toa.io/storages.mongodb
+
+
+
+
+
+# [1.0.0-alpha.321](https://github.com/toa-io/toa/compare/v1.0.0-alpha.320...v1.0.0-alpha.321) (2026-09-28)
+
+### Bug Fixes
+
+* **storages.mongodb:** commit a set of entries all or nothing ([dafecf0](https://github.com/toa-io/toa/commit/dafecf096bac99c4aca5b697a0d7d9f6f6d82daf))
+
+
 # [1.0.0-alpha.320](https://github.com/toa-io/toa/compare/v1.0.0-alpha.319...v1.0.0-alpha.320) (2026-09-28)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/storages.mongodb",
-  "version": "1.0.0-alpha.320",
+  "version": "1.0.0-alpha.322",
   "type": "module",
   "description": "Toa MongoDB Storage Connector",
   "author": "temich <tema.gurtovoy@gmail.com>",
@@ -21,12 +21,12 @@
   },
   "dependencies": {
     "@toa.io/conveyor": "1.0.0-alpha.311",
-    "@toa.io/core": "1.0.0-alpha.320",
-    "@toa.io/definitions": "1.0.0-alpha.320",
+    "@toa.io/core": "1.0.0-alpha.322",
+    "@toa.io/definitions": "1.0.0-alpha.322",
     "@toa.io/generic": "1.0.0-alpha.311",
     "@toa.io/pointer": "1.0.0-alpha.311",
     "mongodb": "7.6.0",
     "openspan": "1.0.0-alpha.305"
   },
-  "gitHead": "5ef92ab939a596e4ac820965c59c015820eba7b2"
+  "gitHead": "ef65352a8bd7bc0ef400fcc8cde0e19a3bb92199"
 }

package/src/storage.js

@@ -278,6 +278,10 @@ export class Storage extends Connector {
     return committed === true
   }
 
+  /**
+   * A transition over a set, committed as one compare-and-swap: every record is written at the
+   * version it was read at, and its rows with it, or nothing is and the answer is `false`.
+   */
   async massStore(entities, rows = undefined, attempt = 0) {
     if (entities.length === 0) return true
 
@@ -288,9 +292,10 @@ export class Storage extends Connector {
         const { VERSION, ...rest } = record
 
         return {
-          // upsert in required when document is deleted
+          // one the read did not find: absent, and inserted, or deleted, and revived — a live
+          // one makes the upsert collide on `_id`, which is the swap lost
           updateOne: {
-            filter: { _id: entity.id },
+            filter: { _id: entity.id, DELETED: { $ne: null } },
             update: {
               $set: {
                 ...rest,
@@ -310,19 +315,39 @@ export class Storage extends Connector {
         }
     })
 
+    let committed
+
     try {
-      await this.#client.transaction(async (session) => {
-        await this.command(
-          'bulkWrite',
-          { operations: operations.length },
-          async () => await this.#collection.bulkWrite(operations, { session })
-        )
+      committed = await this.#client.transaction(async (session) => {
+        let result
+
+        try {
+          result = await this.command(
+            'bulkWrite',
+            { operations: operations.length },
+            async () => await this.#collection.bulkWrite(operations, { session })
+          )
+        } catch (error) {
+          if (!collidedOnId(error)) throw error
+
+          await session.abortTransaction()
+
+          return false
+        }
+
+        // a replacement whose version moved matches nothing, which is no error to a bulk
+        // write: without this the rest of the set would be committed around it
+        if (result.matchedCount + result.upsertedCount < operations.length) {
+          await session.abortTransaction()
+
+          return false
+        }
 
         if (rows !== undefined && this.#outbox !== undefined)
           await this.#outbox.insertMany(rows, session)
-      })
 
-      return true
+        return true
+      })
     } catch (error) {
       console.error('MongoDB error', error)
 
@@ -331,6 +356,11 @@ export class Storage extends Connector {
       if (retry) return await this.massStore(entities, rows, attempt + 1)
       else return false
     }
+
+    // counted once per set: one commit lost, and one retry
+    if (committed !== true) conflicted(this.#collection.collectionName)
+
+    return committed === true
   }
 
   /**
@@ -574,14 +604,18 @@ const ERR_DUPLICATE_KEY = 11000
 /** what the transaction answers where the call it carries has already been made */
 const MADE = Symbol('made')
 
+/** whether the key a write collided on is `_id` */
+function collidedOnId(error) {
+  if (error?.code !== ERR_DUPLICATE_KEY) return false
+
+  return error.keyPattern === undefined
+    ? error.message.includes(' index: _id_ ') // AWS DocumentDB, and a bulk write
+    : error.keyPattern._id === 1
+}
+
 async function retriable(error, attempt) {
   if (error.code === ERR_DUPLICATE_KEY) {
-    const id =
-      error.keyPattern === undefined
-        ? error.message.includes(' index: _id_ ') // AWS DocumentDB
-        : error.keyPattern._id === 1
-
-    if (id) return false
+    if (collidedOnId(error)) return false
     else throw new exceptions.DuplicateException()
   } else if (error.cause?.code === 'ECONNREFUSED') {
     if (attempt === LAST_ATTEMPT) throw error

package/test/storage.test.js

@@ -6,6 +6,7 @@ import { Storage } from '../src/storage.js'
 
 let collection
 let db
+let session
 let storage
 
 beforeEach(async () => {
@@ -19,9 +20,14 @@ beforeEach(async () => {
 
   db = { collection: mock.fn(() => null) }
 
-  const session = { endSession: async () => undefined }
+  session = {
+    endSession: async () => undefined,
+    abortTransaction: mock.fn(async () => undefined)
+  }
+
   const instance = { client: { startSession: () => session } }
-  const client = { collection, db, instance, link: () => null }
+  const transaction = async (fn) => fn(session)
+  const client = { collection, db, instance, transaction, link: () => null }
 
   storage = new Storage(client, { schema: { properties: {} } })
 
@@ -256,3 +262,55 @@ describe('converge', () => {
     assert.equal(await storage.converge(record), false)
   })
 })
+
+describe('massStore', () => {
+  const stored = { id: 'a1', VERSION: 3, foo: 1 }
+  const created = { id: 'b2', VERSION: 1, foo: 1 }
+
+  const operations = () => collection.bulkWrite.mock.calls[0].arguments[0]
+
+  beforeEach(() => {
+    collection.bulkWrite = mock.fn(async (operations) => ({
+      matchedCount: operations.length,
+      upsertedCount: 0
+    }))
+  })
+
+  it('should replace a record only at the version it was read at', async () => {
+    await storage.massStore([stored])
+
+    assert.deepEqual(operations()[0].replaceOne.filter, { _id: 'a1', VERSION: 2 })
+  })
+
+  it('should create a record only where none but a deleted one holds its id', async () => {
+    await storage.massStore([created])
+
+    const { filter, upsert } = operations()[0].updateOne
+
+    assert.deepEqual(filter, { _id: 'b2', DELETED: { $ne: null } })
+    assert.equal(upsert, true)
+  })
+
+  it('should answer true where every record was written', async () => {
+    assert.equal(await storage.massStore([stored, created]), true)
+    assert.equal(session.abortTransaction.mock.callCount(), 0)
+  })
+
+  it('should abort and answer false where a record was not matched', async () => {
+    collection.bulkWrite = mock.fn(async () => ({ matchedCount: 1, upsertedCount: 0 }))
+
+    assert.equal(await storage.massStore([stored, { ...stored, id: 'c3' }]), false)
+    assert.equal(session.abortTransaction.mock.callCount(), 1)
+  })
+
+  it('should abort and answer false where a record being created exists', async () => {
+    collection.bulkWrite = mock.fn(async () => {
+      throw Object.assign(new Error('E11000 duplicate key error index: _id_ dup key'), {
+        code: 11000
+      })
+    })
+
+    assert.equal(await storage.massStore([created]), false)
+    assert.equal(session.abortTransaction.mock.callCount(), 1)
+  })
+})