hide-a-bed 4.0.3 → 4.1.2

package/README.md

@@ -4,47 +4,75 @@ API
 ### Setup
 
 Depending on your environment, use import or require
-
-```
-import { get, put, patch, remove, bulkSave, bulkGet, bulkRemove, query } from 'hide-a-bed'
-```
-```
-const { get, put, patch, remove, bulkSave, bulkGet, bulkRemove, query } = require('hide-a-bed')
-```
+```import { get, put, query } from 'hide-a-bed'```
+or
+```const { get, put, query } = require('hide-a-bed')```
 
 ### Config
 
 Anywhere you see a config, it is an object with the following setup
+```{ couch: 'https://username:pass@the.couch.url.com:5984' }```
+And it is passed in as the first argument of all the functions
+```const doc = await get(config, 'doc-123')```
 
-```
-{ couch: 'https://username:pass@the.couch.url.com:5984' }
-```
-Couch get is weird. We have chosen to return ```undefined``` if the doc is not found. All other things throw. If you want 
-not_found to also throw an exception, add the following to your config:
+See [Advanced Config Options](#advanced-config-options) for more advanced settings.
+
+#### bindConfig 
 
+A convience method to bind the config, so you dont need to pass it in.
 ```
-{ throwOnGetNotFound: true, couch: '...' }
+import { bindConfig } from 'hide-a-bed'
+const db = bindConfig(process.env)
+const doc = db.get('doc-123')
 ```
 
+### API Quick Reference
+
+| Document Operations | Bulk Operations | View Operations |
+|-------------------|-----------------|-----------------|
+| [`get()`](#get) | [`bulkGet()`](#bulkget) | [`query()`](#query) |
+| [`put()`](#put) | [`bulkSave()`](#bulksave) | [`queryStream()`](#querystream) |
+| [`patch()`](#patch) | [`bulkRemove()`](#bulkremove) | [`createQuery()`](#createquery) |
+| [`patchDangerously()`](#patchdangerously) | [`bulkGetDictionary()`](#bulkgetdictionary) | |
+| [`getAtRev()`](#getatrev) | [`bulkSaveTransaction()`](#bulksavetransaction) | |
+
 ### Document Operations
 
+#### get
 
-#### get(config, id)
 Get a single document by ID.
-- `config`: Object with `couch` URL string
+
+**Parameters:**
+- `config`: Object with couch URL string and optional throwOnGetNotFound flag
+- `id`: Document ID string
+- `config`: Object with 
+   * `couch` URL string
+   * `throwOnGetNotFound` default false. If true, 404 docs throw
 - `id`: Document ID string
 - Returns: Promise resolving to document object or null if not found
 
 ```javascript
 const config = { couch: 'http://localhost:5984/mydb' }
 const doc = await get(config, 'doc-123')
-if (doc) {
-  console.log(doc._id, doc._rev)
+console.log(doc._id, doc._rev)
+
+const notThereIsNull = await get(config, 'does-not-exist')
+console.log(notThereIsNull) // null 
+
+try {
+  const config = { couch: '', throwOnGetNotFound: true }
+  await get(config, 'does-not-exist')
+} catch (err) {
+  if (err.name === 'NotFoundError') console.log('Document not found')
 }
+
 ```
 
-#### put(config, doc) 
+#### put
+
 Save a document.
+
+**Parameters:**
 - `config`: Object with `couch` URL string
 - `doc`: Document object with `_id` property
 - Returns: Promise resolving to response with `ok`, `id`, `rev` properties
@@ -58,16 +86,21 @@ const doc = {
 }
 const result = await put(config, doc)
 // result: { ok: true, id: 'doc-123', rev: '1-abc123' }
+
+// imaginary rev returns a conflict
+const doc = { _id: 'notThereDoc', _rev: '32-does-not-compute'}
+const result2 = await db.put(doc)
+console.log(result2) // { ok: false, error: 'conflict', statusCode: 409 }
 ```
 
-#### patch(config, id, properties)
-Update specific properties of a document with retry mechanism.
-- `config`: Object with:
-  - `couch`: URL string
-  - `retries`: Optional number of retry attempts (default: 5)
-  - `delay`: Optional milliseconds between retries (default: 1000)
+#### patch
+
+Update specific properties of a document, you must know the _rev, and passed in with properties.
+
+**Parameters:**
+- `config`: Object with couch URL string
 - `id`: Document ID string
-- `properties`: Object with properties to update
+- `properties`: Object with properties to update, one _must_ be the current _rev
 - Returns: Promise resolving to response with `ok`, `id`, `rev` properties
 
 ```javascript
@@ -77,29 +110,66 @@ const config = {
   delay: 500
 }
 const properties = { 
+  _rev: '3-fdskjhfsdkjhfsd',
   name: 'Alice Smith',
   updated: true
 }
 const result = await patch(config, 'doc-123', properties)
 // result: { ok: true, id: 'doc-123', rev: '2-xyz789' }
 ```
+#### patchDangerously
 
-#### remove(config, id)
-Delete a document by ID.
-- `config`: Object with `couch` URL string
-- `id`: Document ID string to delete
-- Returns: Promise resolving to response with `ok` and `rev` properties
+Update specific properties of a document, no _rev is needed.
+
+**Parameters:**
+- `config`: Object with couch URL string
+- `id`: Document ID string
+- `properties`: Object with properties to update
+
+*warning* - this can clobber data. It will retry even if a conflict happens. There are some use cases for this, but you have been warned, hence the name.
+
+- `id`: Document ID string
+- `properties`: Object with properties to update
+- Returns: Promise resolving to response with `ok`, `id`, `rev` properties
+
+```javascript
+const config = { 
+  couch: 'http://localhost:5984/mydb',
+  retries: 3,
+  delay: 500
+}
+const properties = { 
+  name: 'Alice Smith',
+  updated: true
+}
+const result = await patchDangerously(config, 'doc-123', properties)
+// result: { ok: true, id: 'doc-123', rev: '2-xyz789' }
+```
+
+#### getAtRev
+
+Return a document at the rev specified.
+
+**Parameters:**
+- `config`: Object with couch URL string
+- `id`: Document ID string
+- `rev`: Revision string to retrieve
+
+*CouchDB* is not a version control db. This is a special function for unique situations. The _rev might not be around as couch cleans up old revs.
 
 ```javascript
 const config = { couch: 'http://localhost:5984/mydb' }
-const result = await remove(config, 'doc-123')
-// result: { ok: true, id: 'doc-123', rev: '2-def456' }
+const doc = await getAtRev(config, 'doc-123', '2-fsdjfsdakljfsajlksd')
+console.log(doc._id, doc._rev)
 ```
 
 ### Bulk Operations
 
-#### bulkSave(config, docs)
+#### bulkSave
+
 Save multiple documents in one request.
+
+**Parameters:**
 - `config`: Object with `couch` URL string
 - `docs`: Array of document objects, each with `_id`
 - Returns: Promise resolving to array of results with `ok`, `id`, `rev` for each doc
@@ -117,24 +187,33 @@ const results = await bulkSave(config, docs)
 // ]
 ```
 
-#### bulkGet(config, ids)
+#### bulkGet
+
 Get multiple documents by ID.
+
+**Parameters:**
 - `config`: Object with `couch` URL string
 - `ids`: Array of document ID strings
 - Returns: Promise resolving to array of documents
 
+Not found documents will still have a row in the results, but the doc will be null, and the error property will be set
+
 ```javascript
 const config = { couch: 'http://localhost:5984/mydb' }
-const ids = ['doc1', 'doc2']
+const ids = ['doc1', 'doc2', 'doesNotExist']
 const docs = await bulkGet(config, ids)
 // docs: [
 //   { _id: 'doc1', _rev: '1-abc123', type: 'user', name: 'Alice' },
-//   { _id: 'doc2', _rev: '1-def456', type: 'user', name: 'Bob' }
+//   { _id: 'doc2', _rev: '1-def456', type: 'user', name: 'Bob' },
+//   { key: 'notThereDoc', error: 'not_found' }
 // ]
 ```
 
-#### bulkRemove(config, ids)
+#### bulkRemove
+
 Delete multiple documents in one request.
+
+**Parameters:**
 - `config`: Object with `couch` URL string
 - `ids`: Array of document ID strings to delete
 - Returns: Promise resolving to array of results with `ok`, `id`, `rev` for each deletion
@@ -149,10 +228,99 @@ const results = await bulkRemove(config, ids)
 // ]
 ```
 
+#### bulkGetDictionary
+
+Adds some convenience to bulkGet. Found and notFound documents are separated. Both properties are records of id to result. This makes it easy to deal with the results.
+
+**Parameters:**
+- `config`: Object with `couch` URL string
+- `ids`: Array of document ID strings to delete
+- Returns: Promise resolving to an object with found and notFound properties.
+
+*found* looks like 
+```
+{ 
+  id1: { _id: 'id1', _rev: '1-221', data: {} },
+  id2: { _id: 'id2', _rev: '4-421', data: {} },
+}
+```
+
+*notFound* looks like 
+```
+{
+  id3: { key: 'id1', error: 'not_found' }
+}
+```
+
+```javascript
+const config = { couch: 'http://localhost:5984/mydb' }
+const ids = ['doc1', 'doc2']
+const results = await bulkGetDictionary(config, ids)
+// results: {
+//   found: {
+//     id1: { _id: 'id1', _rev: '1-221', data: {} },
+//     id2: { _id: 'id2', _rev: '4-421', data: {} },
+//   },
+//   notFound: {
+//      id3: { key: 'id1', error: 'not_found' }
+//   }
+// }
+```
+
+#### bulkSaveTransaction
+
+Perform a bulk save operation with all-or-nothing semantics.
+
+**Parameters:**
+- `config`: Object with `couch` URL string
+- `transactionId`: Unique identifier for the transaction
+- `docs`: Array of document objects to save
+- Returns: Promise resolving to array of results with `ok`, `id`, `rev` for each doc
+
+This operation ensures that either all documents are saved successfully, or none are, maintaining data consistency. If any document fails to save, the operation will attempt to roll back all changes.
+
+Note: The transactionId has to be unique for the lifetime of the app. It is used to prevent two processes from executing the same transaction. It is up to you to craft a transactionId that uniquely represents this transaction, and that also is the same if another process tries to generate it.
+
+Exceptions to handle:
+- `TransactionSetupError`: Thrown if the transaction document cannot be created. Usually because it already exists
+- `TransactionVersionConflictError`: Thrown if there are version conflicts with existing documents.
+- `TransactionBulkOperationError`: Thrown if the bulk save operation fails for some documents.
+- `TransactionRollbackError`: Thrown if the rollback operation fails after a transaction failure.
+
+```javascript
+const config = { couch: 'http://localhost:5984/mydb' }
+const transactionId = 'txn-123'
+const docs = [
+  { _id: 'doc1', type: 'user', name: 'Alice', _rev: '1-abc123' },
+  { _id: 'doc2', type: 'user', name: 'Bob', _rev: '1-def456' }
+]
+
+try {
+  const results = await bulkSaveTransaction(config, transactionId, docs)
+  console.log('Transaction successful:', results)
+} catch (error) {
+  if (error instanceof TransactionSetupError) {
+    // the transaction could not start - usually an existing transaction with the same id
+    console.error('Transaction setup failed:', error)
+  } else if (error instanceof TransactionVersionConflictError) {
+    // one or more of the versions of the docs provided dont match with what is currently in the db
+    console.error('Version conflict error:', error)
+  } else if (error instanceof TransactionRollbackError) {
+    // the transaction was rolled back - so the 'or none' condition occured
+    console.error('Rollback error:', error)
+  } else {
+    console.error('Unexpected error:', error)
+  }
+}
+```
+
 ### View Queries
 
-#### query(config, view, options)
+#### query
+
 Query a view with options.
+
+**Parameters:**
 - `config`: Object with `couch` URL string
 - `view`: View path string (e.g. '_design/doc/_view/name')
 - `options`: Optional object with query parameters:
@@ -191,6 +359,104 @@ const result = await query(config, view, options)
 // }
 ```
 
+#### createQuery()
+Create a query builder to help construct view queries with a fluent interface.
+- Returns: QueryBuilder instance with methods:
+  - `key(value)`: Set exact key match
+  - `startKey(value)`: Set range start key
+  - `endKey(value)`: Set range end key
+  - `descending(bool)`: Set descending sort order
+  - `skip(number)`: Set number of results to skip
+  - `limit(number)`: Set max number of results
+  - `includeDocs(bool)`: Include full documents
+  - `reduce(bool)`: Enable/disable reduce
+  - `group(bool)`: Enable/disable grouping
+  - `groupLevel(number)`: Set group level
+  - `build()`: Return the constructed query options object
+
+```javascript
+const options = createQuery()
+  .startKey('A')
+  .endKey('B')
+  .includeDocs(true)
+  .limit(10)
+  .build()
+
+const result = await query(config, view, options)
+```
+
+#### queryStream
+
+Use Cases *Streaming Data*
+
+**Parameters:**
+- `config`: Object with couch URL string
+- `view`: View path string
+- `options`: Query options object
+- `onRow`: Function called for each row in the results
+
+Want to stream data from couch? You can with queryStream. It looks identical to query, except you add an extra 'onRow' function
+
+Here is a small hapi example of streaming data from couch to the client as ndjson. 
+We do a small transform by only streaming the doc. you can do a lot of things in the onrow function.
+
+```
+import Hapi from '@hapi/hapi';
+import { Readable } from 'stream';
+import { queryStream } from bindConfig(process.env)
+const view = '_design/users/_view/by_name'
+
+const init = async () => {
+  const server = Hapi.server({ port: 3000 })
+  server.route({
+    method: 'GET',
+    path: '/stream',
+    handler: async (req, h) => {
+      const stream = new Readable({ read() {} });
+      const onRow = ({id, key, value, doc}) => stream.push(JSON.stringify(doc) + '\n')
+      const options = { startkey: req.query.startLetter, endkey: req.query.startLetter + '|', include_docs: true}
+      await queryStream(view, options, onRow)
+      stream.push(null) // end stream
+      return h.response(stream).type('application/x-ndjson');
+    }
+  })
+
+  await server.start();
+  console.log(`Server running on ${server.info.uri}`);
+}
+init()
+```
+Advanced Config Options
+=======================
+
+The config object supports the following properties:
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| couch | string | required | The URL of the CouchDB database |
+| throwOnGetNotFound | boolean | false | If true, throws an error when get() returns 404. If false, returns undefined |
+| bindWithRetry | boolean | true | When using bindConfig(), adds retry logic to bound methods |
+| maxRetries | number | 3 | Maximum number of retry attempts for retryable operations |
+| initialDelay | number | 1000 | Initial delay in milliseconds before first retry |
+| backoffFactor | number | 2 | Multiplier for exponential backoff between retries |
+| useConsoleLogger | boolean | false | If true, enables console logging when no logger is provided |
+| logger | object/function | undefined | Custom logging interface (winston-style object or function) |
+
+Example configuration with all options:
+```javascript
+const config = {
+  couch: 'http://localhost:5984/mydb',
+  throwOnGetNotFound: true,
+  bindWithRetry: true,
+  maxRetries: 5,
+  initialDelay: 2000,
+  backoffFactor: 1.5,
+  useConsoleLogger: true,
+  logger: (level, ...args) => console.log(level, ...args)
+}
+```
+
+
 Logging Support
 ==============
 
@@ -235,38 +501,3 @@ Each operation logs appropriate information at these levels:
 - debug: Detailed operation information
 
 
-Streaming Support
-=================
-
-Want to stream data from couch? You can with queryStream. It looks identical to query, except you add an extra 'onRow' function
-
-Here is a small hapi example of streaming data from couch to the client as ndjson. 
-We do a small transform by only streaming the doc. you can do a lot of things in the onrow function.
-
-```
-import Hapi from '@hapi/hapi';
-import { Readable } from 'stream';
-import { queryStream } from bindConfig(process.env)
-const view = '_design/users/_view/by_name'
-
-const init = async () => {
-  const server = Hapi.server({ port: 3000 })
-  server.route({
-    method: 'GET',
-    path: '/stream',
-    handler: async (request, h) => {
-      const stream = new Readable({ read() {} });
-      const onRow = ({id, key, value, doc}) => stream.push(JSON.stringify(doc) + '\n')
-      const options = { startkey: req.query.startLetter, endkey: req.query.startLetter + '|', include_docs: true}
-      await queryStream(view, options, onRow)
-      stream.push(null) // end stream
-      return h.response(stream).type('application/x-ndjson');
-    }
-  })
-
-  await server.start();
-  console.log(`Server running on ${server.info.uri}`);
-}
-init()
-```
-

package/cjs/impl/bulk.cjs

@@ -29,14 +29,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var bulk_exports = {};
 __export(bulk_exports, {
   bulkGet: () => bulkGet,
+  bulkGetDictionary: () => bulkGetDictionary,
   bulkRemove: () => bulkRemove,
-  bulkSave: () => bulkSave
+  bulkSave: () => bulkSave,
+  bulkSaveTransaction: () => bulkSaveTransaction
 });
 module.exports = __toCommonJS(bulk_exports);
 var import_needle = __toESM(require("needle"), 1);
 var import_bulk = require("../schema/bulk.cjs");
+var import_retry = require("./retry.cjs");
+var import_crud = require("./crud.cjs");
 var import_errors = require("./errors.cjs");
+var import_transactionErrors = require("./transactionErrors.cjs");
 var import_logger = require("./logger.cjs");
+var import_crud2 = require("../schema/crud.cjs");
+var import_trackedEmitter = require("./trackedEmitter.cjs");
 const opts = {
   json: true,
   headers: {
@@ -83,10 +90,10 @@ const bulkGet = import_bulk.BulkGet.implement(async (config, ids) => {
   const keys = ids;
   logger.info(`Starting bulk get for ${keys.length} documents`);
   const url = `${config.couch}/_all_docs?include_docs=true`;
-  const body = { keys };
+  const payload = { keys };
   let resp;
   try {
-    resp = await (0, import_needle.default)("post", url, body, opts);
+    resp = await (0, import_needle.default)("post", url, payload, opts);
   } catch (err) {
     logger.error("Network error during bulk get:", err);
     import_errors.RetryableError.handleNetworkError(err);
@@ -103,17 +110,158 @@ const bulkGet = import_bulk.BulkGet.implement(async (config, ids) => {
     logger.error(`Unexpected status code: ${resp.statusCode}`);
     throw new Error("could not fetch");
   }
-  const rows = resp?.body?.rows || [];
-  const docs = rows.map((r) => r.doc);
-  logger.info(`Successfully retrieved ${docs.length} documents`);
-  return docs;
+  const body = resp.body;
+  return body;
 });
 const bulkRemove = import_bulk.BulkRemove.implement(async (config, ids) => {
   const logger = (0, import_logger.createLogger)(config);
   logger.info(`Starting bulk remove for ${ids.length} documents`);
-  const docs = await bulkGet(config, ids);
+  const resp = await bulkGet(config, ids);
+  const toRemove = [];
+  resp.rows.forEach((row) => {
+    if (!row.doc) return;
+    try {
+      const d = import_crud2.CouchDoc.parse(row.doc);
+      d._deleted = true;
+      toRemove.push(d);
+    } catch (e) {
+      logger.warn(`Invalid document structure in bulk remove: ${row.id}`, e);
+    }
+  });
+  return bulkSave(config, toRemove);
+});
+const bulkGetDictionary = import_bulk.BulkGetDictionary.implement(async (config, ids) => {
+  const resp = await bulkGet(config, ids);
+  const results = { found: {}, notFound: {} };
+  resp.rows.forEach(
+    /** @param { import('../schema/query.mjs').ViewRowSchema } row */
+    (row) => {
+      if (!row.key) return;
+      if (row.error) {
+        results.notFound[row.key] = row;
+        return;
+      }
+      try {
+        const doc = import_crud2.CouchDoc.parse(row.doc);
+        results.found[doc._id] = doc;
+      } catch (e) {
+        results.notFound[row.key] = row;
+      }
+    }
+  );
+  return results;
+});
+const bulkSaveTransaction = import_bulk.BulkSaveTransaction.implement(async (config, transactionId, docs) => {
+  const emitter = (0, import_trackedEmitter.setupEmitter)(config);
+  const logger = (0, import_logger.createLogger)(config);
+  const retryOptions = {
+    maxRetries: config.maxRetries ?? 10,
+    initialDelay: config.initialDelay ?? 1e3,
+    backoffFactor: config.backoffFactor ?? 2
+  };
+  const _put = config.bindWithRetry ? (0, import_retry.withRetry)(import_crud.put.bind(null, config), retryOptions) : import_crud.put.bind(null, config);
+  logger.info(`Starting bulk save transaction ${transactionId} for ${docs.length} documents`);
+  const txnDoc = {
+    _id: `txn:${transactionId}`,
+    _rev: null,
+    type: "transaction",
+    status: "pending",
+    changes: docs,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  let txnresp = await _put(txnDoc);
+  logger.debug("Transaction document created:", txnDoc, txnresp);
+  await emitter.emit("transaction-created", { txnresp, txnDoc });
+  if (txnresp.error) {
+    throw new import_transactionErrors.TransactionSetupError("Failed to create transaction document", {
+      error: txnresp.error,
+      response: txnresp.body
+    });
+  }
+  const existingDocs = await bulkGetDictionary(config, docs.map((d) => d._id));
+  logger.debug("Fetched current revisions of documents:", existingDocs);
+  await emitter.emit("transaction-revs-fetched", existingDocs);
+  const revErrors = [];
+  docs.forEach((d) => {
+    if (existingDocs.found[d._id] && existingDocs.found[d._id]._rev !== d._rev) revErrors.push(d._id);
+    if (existingDocs.notFound[d._id] && d._rev) revErrors.push(d._id);
+  });
+  if (revErrors.length > 0) {
+    throw new import_transactionErrors.TransactionVersionConflictError(revErrors);
+  }
+  logger.debug("Checked document revisions:", existingDocs);
+  await emitter.emit("transaction-revs-checked", existingDocs);
+  const providedDocsById = {};
   docs.forEach((d) => {
-    d._deleted = true;
+    if (!d._id) return;
+    providedDocsById[d._id] = d;
   });
-  return bulkSave(config, docs);
+  const newDocsToRollback = [];
+  const potentialExistingDocsToRollack = [];
+  const failedDocs = [];
+  try {
+    logger.info("Transaction started:", txnDoc);
+    await emitter.emit("transaction-started", txnDoc);
+    const results = await bulkSave(config, docs);
+    logger.info("Transaction updates applied:", results);
+    await emitter.emit("transaction-updates-applied", results);
+    results.forEach((r) => {
+      if (!r.id) return;
+      if (!r.error) {
+        if (existingDocs.notFound[r.id]) newDocsToRollback.push(r);
+        if (existingDocs.found[r.id]) potentialExistingDocsToRollack.push(r);
+      } else {
+        failedDocs.push(r);
+      }
+    });
+    if (failedDocs.length > 0) {
+      throw new import_transactionErrors.TransactionBulkOperationError(failedDocs);
+    }
+    txnDoc.status = "completed";
+    txnDoc._rev = txnresp.rev;
+    txnresp = await _put(txnDoc);
+    logger.info("Transaction completed:", txnDoc);
+    await emitter.emit("transaction-completed", { txnresp, txnDoc });
+    if (txnresp.statusCode !== 201) {
+      logger.error("Failed to update transaction status to completed");
+    }
+    return results;
+  } catch (error) {
+    logger.error("Transaction failed, attempting rollback:", error);
+    const toRollback = [];
+    potentialExistingDocsToRollack.forEach((row) => {
+      if (!row.id || !row.rev) return;
+      const doc = existingDocs.found[row.id];
+      doc._rev = row.rev;
+      toRollback.push(doc);
+    });
+    newDocsToRollback.forEach((d) => {
+      if (!d.id || !d.rev) return;
+      const before = structuredClone(providedDocsById[d.id]);
+      before._rev = d.rev;
+      before._deleted = true;
+      toRollback.push(before);
+    });
+    const bulkRollbackResult = await bulkSave(config, toRollback);
+    let status = "rolled_back";
+    bulkRollbackResult.forEach((r) => {
+      if (r.error) status = "rollback_failed";
+    });
+    logger.warn("Transaction rolled back:", { bulkRollbackResult, status });
+    await emitter.emit("transaction-rolled-back", { bulkRollbackResult, status });
+    txnDoc.status = status;
+    txnDoc._rev = txnresp.rev;
+    txnresp = await _put(txnDoc);
+    logger.warn("Transaction rollback status updated:", txnDoc);
+    await emitter.emit("transaction-rolled-back-status", { txnresp, txnDoc });
+    if (txnresp.statusCode !== 201) {
+      logger.error("Failed to update transaction status to rolled_back");
+    }
+    throw new import_transactionErrors.TransactionRollbackError(
+      "Transaction failed and rollback was unsuccessful",
+      /** @type {Error} */
+      error,
+      bulkRollbackResult
+    );
+  }
 });