@naturalcycles/db-lib 9.0.0 → 9.1.0

package/dist/adapter/file/file.db.d.ts

@@ -1,6 +1,6 @@
 import { JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { BaseCommonDB, CommonDBSupport, DBOperation, DBSaveBatchOperation, DBTransaction } from '../..';
+import { BaseCommonDB, CommonDBSupport, DBSaveBatchOperation } from '../..';
 import { CommonDB } from '../../common.db';
 import { CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, RunQueryResult } from '../../db.model';
 import { DBQuery } from '../../query/dbQuery';
@@ -32,18 +32,7 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
     saveFile<ROW extends ObjectWithId>(table: string, _rows: ROW[]): Promise<void>;
     saveFiles<ROW extends ObjectWithId>(ops: DBSaveBatchOperation<ROW>[]): Promise<void>;
-    createTransaction(): Promise<FileDBTransaction>;
     sortRows<ROW extends ObjectWithId>(rows: ROW[]): ROW[];
     private logStarted;
     private logFinished;
 }
-export declare class FileDBTransaction implements DBTransaction {
-    private db;
-    constructor(db: FileDB);
-    ops: DBOperation[];
-    /**
-     * Implementation is optimized for loading/saving _whole files_.
-     */
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-}

package/dist/adapter/file/file.db.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileDBTransaction = exports.FileDB = void 0;
+exports.FileDB = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const __1 = require("../..");
@@ -24,7 +24,7 @@ class FileDB extends __1.BaseCommonDB {
             updateSaveMethod: false,
             updateByQuery: false,
             createTable: false,
-            transactions: false,
+            transactions: false, // todo
         };
         this.cfg = {
             sortObjects: true,
@@ -140,9 +140,9 @@ class FileDB extends __1.BaseCommonDB {
         await this.cfg.plugin.saveFiles(ops);
         this.logFinished(started, op);
     }
-    async createTransaction() {
-        return new FileDBTransaction(this);
-    }
+    // override async createTransaction(): Promise<FileDBTransaction> {
+    //   return new FileDBTransaction(this)
+    // }
     sortRows(rows) {
         rows = rows.map(r => (0, js_lib_1._filterUndefinedValues)(r));
         if (this.cfg.sortOnSave) {
@@ -168,69 +168,79 @@ class FileDB extends __1.BaseCommonDB {
     }
 }
 exports.FileDB = FileDB;
-class FileDBTransaction {
-    constructor(db) {
-        this.db = db;
-        this.ops = [];
-    }
-    /**
-     * Implementation is optimized for loading/saving _whole files_.
-     */
-    async commit() {
-        // data[table][id] => row
-        const data = {};
-        // 1. Load all tables data (concurrently)
-        const tables = (0, js_lib_1._uniq)(this.ops.map(o => o.table));
-        await (0, js_lib_1.pMap)(tables, async (table) => {
-            const rows = await this.db.loadFile(table);
-            data[table] = (0, js_lib_1._by)(rows, r => r.id);
-        }, { concurrency: 16 });
-        const backup = (0, js_lib_1._deepCopy)(data);
-        // 2. Apply ops one by one (in order)
-        this.ops.forEach(op => {
-            if (op.type === 'deleteByIds') {
-                op.ids.forEach(id => delete data[op.table][id]);
-            }
-            else if (op.type === 'saveBatch') {
-                op.rows.forEach(r => {
-                    if (!r.id) {
-                        throw new Error('FileDB: row has an empty id');
-                    }
-                    data[op.table][r.id] = r;
-                });
-            }
-            else {
-                throw new Error(`DBOperation not supported: ${op.type}`);
-            }
-        });
-        // 3. Sort, turn it into ops
-        // Not filtering empty arrays, cause it's already filtered in this.saveFiles()
-        const ops = (0, js_lib_1._stringMapEntries)(data).map(([table, map]) => {
-            return {
-                type: 'saveBatch',
-                table,
-                rows: this.db.sortRows((0, js_lib_1._stringMapValues)(map)),
-            };
-        });
-        // 4. Save all files
-        try {
-            await this.db.saveFiles(ops);
-        }
-        catch (err) {
-            const ops = (0, js_lib_1._stringMapEntries)(backup).map(([table, map]) => {
-                return {
-                    type: 'saveBatch',
-                    table,
-                    rows: this.db.sortRows((0, js_lib_1._stringMapValues)(map)),
-                };
-            });
-            // Rollback, ignore rollback error (if any)
-            await this.db.saveFiles(ops).catch(_ => { });
-            throw err;
+// todo: get back and fix it
+// Implementation is optimized for loading/saving _whole files_.
+/*
+export class FileDBTransaction implements DBTransaction {
+  constructor(private db: FileDB) {}
+
+  ops: DBOperation[] = []
+
+  async commit(): Promise<void> {
+    // data[table][id] => row
+    const data: StringMap<StringMap<ObjectWithId>> = {}
+
+    // 1. Load all tables data (concurrently)
+    const tables = _uniq(this.ops.map(o => o.table))
+
+    await pMap(
+      tables,
+      async table => {
+        const rows = await this.db.loadFile(table)
+        data[table] = _by(rows, r => r.id)
+      },
+      { concurrency: 16 },
+    )
+
+    const backup = _deepCopy(data)
+
+    // 2. Apply ops one by one (in order)
+    this.ops.forEach(op => {
+      if (op.type === 'deleteByIds') {
+        op.ids.forEach(id => delete data[op.table]![id])
+      } else if (op.type === 'saveBatch') {
+        op.rows.forEach(r => {
+          if (!r.id) {
+            throw new Error('FileDB: row has an empty id')
+          }
+          data[op.table]![r.id] = r
+        })
+      } else {
+        throw new Error(`DBOperation not supported: ${(op as any).type}`)
+      }
+    })
+
+    // 3. Sort, turn it into ops
+    // Not filtering empty arrays, cause it's already filtered in this.saveFiles()
+    const ops: DBSaveBatchOperation[] = _stringMapEntries(data).map(([table, map]) => {
+      return {
+        type: 'saveBatch',
+        table,
+        rows: this.db.sortRows(_stringMapValues(map)),
+      }
+    })
+
+    // 4. Save all files
+    try {
+      await this.db.saveFiles(ops)
+    } catch (err) {
+      const ops: DBSaveBatchOperation[] = _stringMapEntries(backup).map(([table, map]) => {
+        return {
+          type: 'saveBatch',
+          table,
+          rows: this.db.sortRows(_stringMapValues(map)),
         }
-    }
-    async rollback() {
-        this.ops = [];
-    }
+      })
+
+      // Rollback, ignore rollback error (if any)
+      await this.db.saveFiles(ops).catch(_ => {})
+
+      throw err
+    }
+  }
+
+  async rollback(): Promise<void> {
+    this.ops = []
+  }
 }
-exports.FileDBTransaction = FileDBTransaction;
+*/

package/dist/adapter/inmemory/inMemory.db.d.ts

@@ -1,6 +1,6 @@
 import { JsonSchemaObject, StringMap, JsonSchemaRootObject, ObjectWithId, CommonLogger } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { CommonDB, CommonDBType, DBOperation, DBPatch } from '../..';
+import { CommonDB, CommonDBType, DBOperation, DBPatch, DBTransactionFn } from '../..';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, DBTransaction, RunQueryResult } from '../../db.model';
 import { DBQuery } from '../../query/dbQuery';
 export interface InMemoryDBCfg {
@@ -72,13 +72,13 @@ export declare class InMemoryDB implements CommonDB {
     createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
     getByIds<ROW extends ObjectWithId>(_table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
     saveBatch<ROW extends Partial<ObjectWithId>>(_table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<number>;
-    deleteByIds(_table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    deleteByIds(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<number>;
     updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>): Promise<number>;
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
     runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): ReadableTyped<ROW>;
-    createTransaction(): Promise<DBTransaction>;
+    runInTransaction(fn: DBTransactionFn): Promise<void>;
     /**
      * Flushes all tables (all namespaces) at once.
      */
@@ -92,6 +92,9 @@ export declare class InMemoryDBTransaction implements DBTransaction {
     private db;
     constructor(db: InMemoryDB);
     ops: DBOperation[];
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
     commit(): Promise<void>;
     rollback(): Promise<void>;
 }

package/dist/adapter/inmemory/inMemory.db.js

@@ -77,17 +77,6 @@ class InMemoryDB {
         return ids.map(id => this.data[table][id]).filter(Boolean);
     }
     async saveBatch(_table, rows, opt = {}) {
-        const { tx } = opt;
-        if (tx) {
-            ;
-            tx.ops.push({
-                type: 'saveBatch',
-                table: _table,
-                rows,
-                opt: (0, js_lib_1._omit)(opt, ['tx']),
-            });
-            return;
-        }
         const table = this.cfg.tablesPrefix + _table;
         this.data[table] ||= {};
         rows.forEach(r => {
@@ -107,39 +96,17 @@ class InMemoryDB {
             this.data[table][r.id] = JSON.parse(JSON.stringify(r), nodejs_lib_1.bufferReviver);
         });
     }
-    async deleteByQuery(q, opt = {}) {
+    async deleteByQuery(q, _opt) {
         const table = this.cfg.tablesPrefix + q.table;
         if (!this.data[table])
             return 0;
         const ids = (0, __1.queryInMemory)(q, Object.values(this.data[table])).map(r => r.id);
-        const { tx } = opt;
-        if (tx) {
-            ;
-            tx.ops.push({
-                type: 'deleteByIds',
-                table: q.table,
-                ids,
-                opt: (0, js_lib_1._omit)(opt, ['tx']),
-            });
-            return ids.length;
-        }
         return await this.deleteByIds(q.table, ids);
     }
-    async deleteByIds(_table, ids, opt = {}) {
+    async deleteByIds(_table, ids, _opt) {
         const table = this.cfg.tablesPrefix + _table;
         if (!this.data[table])
             return 0;
-        const { tx } = opt;
-        if (tx) {
-            ;
-            tx.ops.push({
-                type: 'deleteByIds',
-                table: _table,
-                ids,
-                opt: (0, js_lib_1._omit)(opt, ['tx']),
-            });
-            return ids.length;
-        }
         let count = 0;
         ids.forEach(id => {
             if (!this.data[table][id])
@@ -153,7 +120,6 @@ class InMemoryDB {
         const patchEntries = Object.entries(patch);
         if (!patchEntries.length)
             return 0;
-        // todo: can we support tx here? :thinking:
         const table = this.cfg.tablesPrefix + q.table;
         const rows = (0, __1.queryInMemory)(q, Object.values(this.data[table] || {}));
         rows.forEach((row) => {
@@ -180,8 +146,16 @@ class InMemoryDB {
         const table = this.cfg.tablesPrefix + q.table;
         return node_stream_1.Readable.from((0, __1.queryInMemory)(q, Object.values(this.data[table] || {})));
     }
-    async createTransaction() {
-        return new InMemoryDBTransaction(this);
+    async runInTransaction(fn) {
+        const tx = new InMemoryDBTransaction(this);
+        try {
+            await fn(tx);
+            await tx.commit();
+        }
+        catch (err) {
+            await tx.rollback();
+            throw err;
+        }
     }
     /**
      * Flushes all tables (all namespaces) at once.
@@ -243,6 +217,26 @@ class InMemoryDBTransaction {
         this.db = db;
         this.ops = [];
     }
+    async getByIds(table, ids, opt) {
+        return await this.db.getByIds(table, ids, opt);
+    }
+    async saveBatch(table, rows, opt) {
+        this.ops.push({
+            type: 'saveBatch',
+            table,
+            rows,
+            opt,
+        });
+    }
+    async deleteByIds(table, ids, opt) {
+        this.ops.push({
+            type: 'deleteByIds',
+            table,
+            ids,
+            opt,
+        });
+        return ids.length;
+    }
     async commit() {
         const backup = (0, js_lib_1._deepCopy)(this.db.data);
         try {
@@ -261,6 +255,7 @@ class InMemoryDBTransaction {
         }
         catch (err) {
             // rollback
+            this.ops = [];
             this.db.data = backup;
             this.db.cfg.logger.log('InMemoryDB transaction rolled back');
             throw err;

package/dist/base.common.db.d.ts

@@ -1,7 +1,7 @@
 import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDB, CommonDBSupport, CommonDBType } from './common.db';
-import { CommonDBOptions, CommonDBSaveOptions, DBPatch, DBTransaction, RunQueryResult } from './db.model';
+import { CommonDBOptions, CommonDBSaveOptions, DBPatch, DBTransactionFn, RunQueryResult } from './db.model';
 import { DBQuery } from './query/dbQuery';
 /**
  * No-op implementation of CommonDB interface.
@@ -22,5 +22,5 @@ export declare class BaseCommonDB implements CommonDB {
     saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): ReadableTyped<ROW>;
     deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
-    createTransaction(): Promise<DBTransaction>;
+    runInTransaction(fn: DBTransactionFn): Promise<void>;
 }

package/dist/base.common.db.js

@@ -49,8 +49,10 @@ class BaseCommonDB {
     async deleteByIds(table, ids, opt) {
         throw new Error('deleteByIds is not implemented');
     }
-    async createTransaction() {
-        return new dbTransaction_util_1.FakeDBTransaction(this);
+    async runInTransaction(fn) {
+        const tx = new dbTransaction_util_1.FakeDBTransaction(this);
+        await fn(tx);
+        // there's no try/catch and rollback, as there's nothing to rollback
     }
 }
 exports.BaseCommonDB = BaseCommonDB;

package/dist/common.db.d.ts

@@ -1,6 +1,6 @@
 import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
-import { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, DBPatch, DBTransaction, RunQueryResult } from './db.model';
+import type { ReadableTyped } from '@naturalcycles/nodejs-lib';
+import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, DBPatch, DBTransactionFn, RunQueryResult } from './db.model';
 import { DBQuery } from './query/dbQuery';
 export declare enum CommonDBType {
     'document' = "document",
@@ -100,8 +100,12 @@ export interface CommonDB {
     /**
      * Should be implemented as a Transaction (best effort), which means that
      * either ALL or NONE of the operations should be applied.
+     *
+     * Transaction is automatically committed if fn resolves normally.
+     * Transaction is rolled back if fn throws, the error is re-thrown in that case.
+     * Graceful rollback is allowed on tx.rollback()
      */
-    createTransaction: () => Promise<DBTransaction>;
+    runInTransaction: (fn: DBTransactionFn) => Promise<void>;
 }
 /**
  * Manifest of supported features.

package/dist/commondao/common.dao.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { Transform } from 'node:stream';
-import { AnyObject, AsyncMapper, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, Saved, UnixTimestampMillisNumber, Unsaved, ZodSchema } from '@naturalcycles/js-lib';
+import { AnyObject, AsyncMapper, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, Saved, UnixTimestampMillisNumber, Unsaved, ZodSchema } from '@naturalcycles/js-lib';
 import { AjvSchema, ObjectSchema, ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { DBModelType, DBPatch, DBTransaction, RunQueryResult } from '../db.model';
 import { DBQuery, RunnableDBQuery } from '../query/dbQuery';
@@ -169,21 +169,32 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
      * Proxy to this.cfg.db.ping
      */
     ping(): Promise<void>;
-    useTransaction(fn: (tx: CommonDaoTransaction) => Promise<void>): Promise<void>;
-    createTransaction(): Promise<CommonDaoTransaction>;
+    runInTransaction(fn: CommonDaoTransactionFn): Promise<void>;
     protected logResult(started: number, op: string, res: any, table: string): void;
     protected logSaveResult(started: number, op: string, table: string): void;
     protected logStarted(op: string, table: string, force?: boolean): UnixTimestampMillisNumber;
     protected logSaveStarted(op: string, items: any, table: string): UnixTimestampMillisNumber;
 }
+/**
+ * Transaction is committed when the function returns resolved Promise (aka "returns normally").
+ *
+ * Transaction is rolled back when the function returns rejected Promise (aka "throws").
+ */
+export type CommonDaoTransactionFn = (tx: CommonDaoTransaction) => Promise<void>;
+/**
+ * Transaction context.
+ * Has similar API than CommonDao, but all operations are performed in the context of the transaction.
+ */
 export declare class CommonDaoTransaction {
     private tx;
-    constructor(tx: DBTransaction);
-    commit(): Promise<void>;
+    private logger;
+    constructor(tx: DBTransaction, logger: CommonLogger);
+    /**
+     * Perform a graceful rollback without throwing/re-throwing any error.
+     */
     rollback(): Promise<void>;
     getById<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, id: string, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
     getByIds<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, ids: string[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
-    runQuery<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
     save<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, bm: Unsaved<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
     saveBatch<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
     deleteById(dao: CommonDao<any>, id: string, opt?: CommonDaoOptions): Promise<number>;

package/dist/commondao/common.dao.js

@@ -124,7 +124,7 @@ class CommonDao {
         const op = `getByIds ${ids.length} id(s) (${(0, js_lib_1._truncate)(ids.slice(0, 10).join(', '), 50)})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        let dbms = await this.cfg.db.getByIds(table, ids);
+        let dbms = await (opt.tx || this.cfg.db).getByIds(table, ids);
         if (!opt.raw && this.cfg.hooks.afterLoad && dbms.length) {
             dbms = (await (0, js_lib_1.pMap)(dbms, async (dbm) => await this.cfg.hooks.afterLoad(dbm))).filter(js_lib_1._isTruthy);
         }
@@ -662,7 +662,7 @@ class CommonDao {
         const started = this.logSaveStarted(op, bms, table);
         const { excludeFromIndexes } = this.cfg;
         const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds;
-        await this.cfg.db.saveBatch(table, dbms, {
+        await (opt.tx || this.cfg.db).saveBatch(table, dbms, {
             excludeFromIndexes,
             assignGeneratedIds,
             ...opt,
@@ -781,7 +781,7 @@ class CommonDao {
         const op = `deleteByIds(${ids.join(', ')})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const count = await this.cfg.db.deleteByIds(table, ids, opt);
+        const count = await (opt.tx || this.cfg.db).deleteByIds(table, ids, opt);
         this.logSaveResult(started, op, table);
         return count;
     }
@@ -991,21 +991,17 @@ class CommonDao {
     async ping() {
         await this.cfg.db.ping();
     }
-    async useTransaction(fn) {
-        const tx = await this.cfg.db.createTransaction();
-        const daoTx = new CommonDaoTransaction(tx);
-        try {
-            await fn(daoTx);
-            await daoTx.commit();
-        }
-        catch (err) {
-            await daoTx.rollback();
-            throw err;
-        }
-    }
-    async createTransaction() {
-        const tx = await this.cfg.db.createTransaction();
-        return new CommonDaoTransaction(tx);
+    async runInTransaction(fn) {
+        await this.cfg.db.runInTransaction(async (tx) => {
+            const daoTx = new CommonDaoTransaction(tx, this.cfg.logger);
+            try {
+                await fn(daoTx);
+            }
+            catch (err) {
+                await daoTx.rollback();
+                throw err;
+            }
+        });
     }
     logResult(started, op, res, table) {
         if (!this.cfg.logLevel)
@@ -1062,65 +1058,57 @@ class CommonDao {
     }
 }
 exports.CommonDao = CommonDao;
+/**
+ * Transaction context.
+ * Has similar API than CommonDao, but all operations are performed in the context of the transaction.
+ */
 class CommonDaoTransaction {
-    constructor(tx) {
+    constructor(tx, logger) {
         this.tx = tx;
+        this.logger = logger;
     }
-    async commit() {
-        await this.tx.commit();
-    }
+    /**
+     * Perform a graceful rollback without throwing/re-throwing any error.
+     */
     async rollback() {
         try {
             await this.tx.rollback();
         }
         catch (err) {
-            console.log(err);
+            // graceful rollback without re-throw
+            this.logger.error(err);
         }
     }
     async getById(dao, id, opt) {
         return (await this.getByIds(dao, [id], opt))[0] || null;
     }
     async getByIds(dao, ids, opt) {
-        try {
-            return await dao.getByIds(ids, { ...opt, tx: this.tx });
-        }
-        catch (err) {
-            await this.rollback();
-            throw err;
-        }
-    }
-    async runQuery(dao, q, opt) {
-        try {
-            return await dao.runQuery(q, { ...opt, tx: this.tx });
-        }
-        catch (err) {
-            await this.rollback();
-            throw err;
-        }
-    }
+        return await dao.getByIds(ids, { ...opt, tx: this.tx });
+    }
+    // todo: Queries inside Transaction are not supported yet
+    // async runQuery<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(
+    //   dao: CommonDao<BM, DBM, any>,
+    //   q: DBQuery<DBM>,
+    //   opt?: CommonDaoOptions,
+    // ): Promise<Saved<BM>[]> {
+    //   try {
+    //     return await dao.runQuery(q, { ...opt, tx: this.tx })
+    //   } catch (err) {
+    //     await this.rollback()
+    //     throw err
+    //   }
+    // }
     async save(dao, bm, opt) {
         return (await this.saveBatch(dao, [bm], opt))[0];
     }
     async saveBatch(dao, bms, opt) {
-        try {
-            return await dao.saveBatch(bms, { ...opt, tx: this.tx });
-        }
-        catch (err) {
-            await this.rollback();
-            throw err;
-        }
+        return await dao.saveBatch(bms, { ...opt, tx: this.tx });
     }
     async deleteById(dao, id, opt) {
         return await this.deleteByIds(dao, [id], opt);
     }
     async deleteByIds(dao, ids, opt) {
-        try {
-            return await dao.deleteByIds(ids, { ...opt, tx: this.tx });
-        }
-        catch (err) {
-            await this.rollback();
-            throw err;
-        }
+        return await dao.deleteByIds(ids, { ...opt, tx: this.tx });
     }
 }
 exports.CommonDaoTransaction = CommonDaoTransaction;

package/dist/db.model.d.ts

@@ -1,4 +1,5 @@
 import type { ObjectWithId } from '@naturalcycles/js-lib';
+import { CommonDB } from './common.db';
 /**
  * Similar to SQL INSERT, UPDATE.
  * Insert will fail if row already exists.
@@ -8,8 +9,24 @@ import type { ObjectWithId } from '@naturalcycles/js-lib';
  * Default is Upsert.
  */
 export type CommonDBSaveMethod = 'upsert' | 'insert' | 'update';
+/**
+ * Transaction is committed when the function returns resolved Promise (aka "returns normally").
+ *
+ * Transaction is rolled back when the function returns rejected Promise (aka "throws").
+ */
+export type DBTransactionFn = (tx: DBTransaction) => Promise<void>;
+/**
+ * Transaction context.
+ * Has similar API than CommonDB, but all operations are performed in the context of the transaction.
+ */
 export interface DBTransaction {
-    commit: () => Promise<void>;
+    getByIds: CommonDB['getByIds'];
+    saveBatch: CommonDB['saveBatch'];
+    deleteByIds: CommonDB['deleteByIds'];
+    /**
+     * Perform a graceful rollback.
+     * It'll rollback the transaction and won't throw/re-throw any errors.
+     */
     rollback: () => Promise<void>;
 }
 export interface CommonDBOptions {