@naturalcycles/db-lib 8.41.1 → 8.42.1

package/dist/adapter/cachedb/cache.db.d.ts

@@ -3,8 +3,9 @@ import { Readable } from 'stream';
 import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { BaseCommonDB } from '../../base.common.db';
 import { CommonDB } from '../../common.db';
-import { RunQueryResult } from '../../db.model';
+import { CommonDBOptions, RunQueryResult } from '../../db.model';
 import { DBQuery } from '../../query/dbQuery';
+import { DBTransaction } from '../../transaction/dbTransaction';
 import { CacheDBCfg, CacheDBCreateOptions, CacheDBOptions, CacheDBSaveOptions, CacheDBStreamOptions } from './cache.db.model';
 /**
  * CommonDB implementation that proxies requests to downstream CommonDB
@@ -29,4 +30,5 @@ export declare class CacheDB extends BaseCommonDB implements CommonDB {
     runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBStreamOptions): Readable;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
+    commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void>;
 }

package/dist/adapter/cachedb/cache.db.js

@@ -195,5 +195,9 @@ class CacheDB extends base_common_db_1.BaseCommonDB {
         }
         return deletedIds;
     }
+    async commitTransaction(tx, opt) {
+        await this.cfg.downstreamDB.commitTransaction(tx, opt);
+        await this.cfg.cacheDB.commitTransaction(tx, opt);
+    }
 }
 exports.CacheDB = CacheDB;

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

@@ -70,13 +70,19 @@ class FileDB extends __1.BaseCommonDB {
             const rows = await this.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)
         tx.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 => (data[op.table][r.id] = r));
+                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}`);
@@ -84,15 +90,29 @@ class FileDB extends __1.BaseCommonDB {
         });
         // 3. Sort, turn it into ops
         // Not filtering empty arrays, cause it's already filtered in this.saveFiles()
-        const ops = Object.keys(data).map(table => {
+        const ops = (0, js_lib_1._stringMapEntries)(data).map(([table, map]) => {
             return {
                 type: 'saveBatch',
                 table,
-                rows: this.sortRows(Object.values(data[table])),
+                rows: this.sortRows((0, js_lib_1._stringMapValues)(map)),
             };
         });
         // 4. Save all files
-        await this.saveFiles(ops);
+        try {
+            await this.saveFiles(ops);
+        }
+        catch (err) {
+            const ops = (0, js_lib_1._stringMapEntries)(backup).map(([table, map]) => {
+                return {
+                    type: 'saveBatch',
+                    table,
+                    rows: this.sortRows((0, js_lib_1._stringMapValues)(map)),
+                };
+            });
+            // Rollback, ignore rollback error (if any)
+            await this.saveFiles(ops).catch(_ => { });
+            throw err;
+        }
     }
     async runQuery(q, _opt) {
         return {

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

@@ -5,7 +5,7 @@ export interface FileDBPersistencePlugin {
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
     loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
-    saveFiles(ops: DBSaveBatchOperation[]): Promise<void>;
+    saveFiles(ops: DBSaveBatchOperation<any>[]): Promise<void>;
 }
 export interface FileDBCfg {
     plugin: FileDBPersistencePlugin;

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

@@ -36,7 +36,7 @@ class InMemoryDB {
     async resetCache(_table) {
         if (_table) {
             const table = this.cfg.tablesPrefix + _table;
-            this.cfg.logger?.log(`reset ${table}`);
+            this.cfg.logger.log(`reset ${table}`);
             this.data[table] = {};
         }
         else {
@@ -44,7 +44,7 @@ class InMemoryDB {
             (await this.getTables()).forEach(table => {
                 this.data[table] = {};
             });
-            this.cfg.logger?.log('reset');
+            this.cfg.logger.log('reset');
         }
     }
     async getTables() {
@@ -79,7 +79,7 @@ class InMemoryDB {
         (_a = this.data)[table] || (_a[table] = {});
         rows.forEach(r => {
             if (!r.id) {
-                this.cfg.logger?.warn({ rows });
+                this.cfg.logger.warn({ rows });
                 throw new Error(`InMemoryDB doesn't support id auto-generation in saveBatch, row without id was given`);
             }
             if (opt.saveMethod === 'insert' && this.data[table][r.id]) {
@@ -125,17 +125,26 @@ class InMemoryDB {
         return stream_1.Readable.from((0, __1.queryInMemory)(q, Object.values(this.data[table] || {})));
     }
     async commitTransaction(tx, opt) {
-        for await (const op of tx.ops) {
-            if (op.type === 'saveBatch') {
-                await this.saveBatch(op.table, op.rows, opt);
-            }
-            else if (op.type === 'deleteByIds') {
-                await this.deleteByIds(op.table, op.ids, opt);
-            }
-            else {
-                throw new Error(`DBOperation not supported: ${op.type}`);
+        const backup = (0, js_lib_1._deepCopy)(this.data);
+        try {
+            for await (const op of tx.ops) {
+                if (op.type === 'saveBatch') {
+                    await this.saveBatch(op.table, op.rows, { ...op.opt, ...opt });
+                }
+                else if (op.type === 'deleteByIds') {
+                    await this.deleteByIds(op.table, op.ids, { ...op.opt, ...opt });
+                }
+                else {
+                    throw new Error(`DBOperation not supported: ${op.type}`);
+                }
             }
         }
+        catch (err) {
+            // rollback
+            this.data = backup;
+            this.cfg.logger.log('InMemoryDB transaction rolled back');
+            throw err;
+        }
     }
     /**
      * Flushes all tables (all namespaces) at once.
@@ -163,7 +172,7 @@ class InMemoryDB {
                 fs.createWriteStream(fname),
             ]);
         });
-        this.cfg.logger?.log(`flushToDisk took ${(0, colors_1.dimGrey)((0, js_lib_1._since)(started))} to save ${(0, colors_1.yellow)(tables)} tables`);
+        this.cfg.logger.log(`flushToDisk took ${(0, colors_1.dimGrey)((0, js_lib_1._since)(started))} to save ${(0, colors_1.yellow)(tables)} tables`);
     }
     /**
      * Restores all tables (all namespaces) at once.
@@ -192,7 +201,7 @@ class InMemoryDB {
             ]);
             this.data[table] = (0, js_lib_1._by)(rows, r => r.id);
         });
-        this.cfg.logger?.log(`restoreFromDisk took ${(0, colors_1.dimGrey)((0, js_lib_1._since)(started))} to read ${(0, colors_1.yellow)(files.length)} tables`);
+        this.cfg.logger.log(`restoreFromDisk took ${(0, colors_1.dimGrey)((0, js_lib_1._since)(started))} to read ${(0, colors_1.yellow)(files.length)} tables`);
     }
 }
 exports.InMemoryDB = InMemoryDB;

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

@@ -22,6 +22,7 @@ export declare class BaseCommonDB implements CommonDB {
     streamQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): ReadableTyped<ROW>;
     /**
      * Naive implementation.
+     * Doesn't support rollback on error, hence doesn't pass dbTest.
      * To be extended.
      */
     commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void>;

package/dist/base.common.db.js

@@ -43,6 +43,7 @@ class BaseCommonDB {
     }
     /**
      * Naive implementation.
+     * Doesn't support rollback on error, hence doesn't pass dbTest.
      * To be extended.
      */
     async commitTransaction(tx, opt) {

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

@@ -1,6 +1,6 @@
 import { AsyncMapper, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, Saved, Unsaved } from '@naturalcycles/js-lib';
 import { AjvSchema, ObjectSchemaTyped, ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { DBModelType, RunQueryResult } from '../db.model';
+import { DBDeleteByIdsOperation, DBModelType, DBOperation, DBSaveBatchOperation, RunQueryResult } from '../db.model';
 import { DBQuery, RunnableDBQuery } from '../query/dbQuery';
 import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions } from './common.dao.model';
 /**
@@ -83,6 +83,12 @@ export declare class CommonDao<BM extends Partial<ObjectWithId<ID>>, DBM extends
     assignIdCreatedUpdated(obj: DBM, opt?: CommonDaoOptions): DBM;
     assignIdCreatedUpdated(obj: BM, opt?: CommonDaoOptions): Saved<BM>;
     assignIdCreatedUpdated(obj: Unsaved<BM>, opt?: CommonDaoOptions): Saved<BM>;
+    tx: {
+        save: (bm: Unsaved<BM>, opt?: CommonDaoSaveOptions<DBM>) => Promise<DBSaveBatchOperation>;
+        saveBatch: (bms: Unsaved<BM>[], opt?: CommonDaoSaveOptions<DBM>) => Promise<DBSaveBatchOperation>;
+        deleteByIds: (ids: ID[], opt?: CommonDaoOptions) => Promise<DBDeleteByIdsOperation>;
+        deleteById: (id: ID, opt?: CommonDaoOptions) => Promise<DBDeleteByIdsOperation>;
+    };
     /**
      * Mutates with id, created, updated
      */
@@ -146,6 +152,7 @@ export declare class CommonDao<BM extends Partial<ObjectWithId<ID>>, DBM extends
      * Proxy to this.cfg.db.ping
      */
     ping(): Promise<void>;
+    runInTransaction(ops: Promise<DBOperation>[]): 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): number;

package/dist/commondao/common.dao.js

@@ -6,6 +6,7 @@ const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const cnst_1 = require("../cnst");
 const db_model_1 = require("../db.model");
 const dbQuery_1 = require("../query/dbQuery");
+const dbTransaction_1 = require("../transaction/dbTransaction");
 const common_dao_model_1 = require("./common.dao.model");
 /* eslint-disable no-dupe-class-members */
 const isGAE = !!process.env['GAE_INSTANCE'];
@@ -21,6 +22,48 @@ class CommonDao {
     constructor(cfg) {
         var _a;
         this.cfg = cfg;
+        this.tx = {
+            save: async (bm, opt = {}) => {
+                const row = (await this.save(bm, { ...opt, tx: true }));
+                return {
+                    type: 'saveBatch',
+                    table: this.cfg.table,
+                    rows: [row],
+                    opt: {
+                        excludeFromIndexes: this.cfg.excludeFromIndexes,
+                        ...opt,
+                    },
+                };
+            },
+            saveBatch: async (bms, opt = {}) => {
+                const rows = (await this.saveBatch(bms, { ...opt, tx: true }));
+                return {
+                    type: 'saveBatch',
+                    table: this.cfg.table,
+                    rows,
+                    opt: {
+                        excludeFromIndexes: this.cfg.excludeFromIndexes,
+                        ...opt,
+                    },
+                };
+            },
+            deleteByIds: async (ids, opt = {}) => {
+                return {
+                    type: 'deleteByIds',
+                    table: this.cfg.table,
+                    ids: ids,
+                    opt,
+                };
+            },
+            deleteById: async (id, opt = {}) => {
+                return {
+                    type: 'deleteByIds',
+                    table: this.cfg.table,
+                    ids: [id],
+                    opt,
+                };
+            },
+        };
         this.cfg = {
             // Default is to NOT log in AppEngine and in CI,
             // otherwise to log Operations
@@ -459,6 +502,9 @@ class CommonDao {
         const idWasGenerated = !bm.id && this.cfg.createId;
         this.assignIdCreatedUpdated(bm, opt); // mutates
         const dbm = await this.bmToDBM(bm, opt);
+        if (opt.tx) {
+            return dbm;
+        }
         const table = opt.table || this.cfg.table;
         if (opt.ensureUniqueId && idWasGenerated)
             await this.ensureUniqueId(table, dbm);
@@ -538,6 +584,9 @@ class CommonDao {
         const table = opt.table || this.cfg.table;
         bms.forEach(bm => this.assignIdCreatedUpdated(bm, opt));
         const dbms = await this.bmsToDBM(bms, opt);
+        if (opt.tx) {
+            return dbms;
+        }
         if (opt.ensureUniqueId)
             throw new js_lib_1.AppError('ensureUniqueId is not supported in saveBatch');
         if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
@@ -811,9 +860,12 @@ class CommonDao {
     async ping() {
         await this.cfg.db.ping();
     }
-    // transaction(): DBTransaction {
-    //   return this.cfg.db.transaction()
-    // }
+    async runInTransaction(ops) {
+        if (!ops.length)
+            return;
+        const resolvedOps = await Promise.all(ops);
+        await this.cfg.db.commitTransaction(dbTransaction_1.DBTransaction.create(resolvedOps));
+    }
     logResult(started, op, res, table) {
         if (!this.cfg.logLevel)
             return;

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

@@ -167,6 +167,16 @@ export interface CommonDaoOptions extends CommonDBOptions {
      * @experimental
      */
     timeout?: number;
+    /**
+     * If passed - operation will not be performed immediately, but instead "added" to the transaction.
+     * In the end - transaction needs to be committed (by calling `commit`).
+     * This API is inspired by Datastore API.
+     *
+     * Only applicable to save* and delete* operations
+     *
+     * @experimental
+     */
+    tx?: boolean;
 }
 /**
  * All properties default to undefined.

package/dist/db.model.d.ts

@@ -45,11 +45,13 @@ export interface DBSaveBatchOperation<ROW extends ObjectWithId = AnyObjectWithId
     type: 'saveBatch';
     table: string;
     rows: ROW[];
+    opt?: CommonDBSaveOptions<ROW>;
 }
 export interface DBDeleteByIdsOperation {
     type: 'deleteByIds';
     table: string;
     ids: string[];
+    opt?: CommonDBOptions;
 }
 export declare enum DBRelation {
     ONE_TO_ONE = "ONE_TO_ONE",

package/dist/index.d.ts

@@ -1,21 +1,19 @@
-import { InMemoryDB, InMemoryDBCfg } from './adapter/inmemory/inMemory.db';
-import { InMemoryKeyValueDB, InMemoryKeyValueDBCfg } from './adapter/inmemory/inMemoryKeyValueDB';
-import { queryInMemory } from './adapter/inmemory/queryInMemory';
-import { BaseCommonDB } from './base.common.db';
-import { DBLibError } from './cnst';
-import { CommonDB } from './common.db';
-import { CommonDao } from './commondao/common.dao';
-import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoLogLevel, CommonDaoOptions, CommonDaoSaveOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDaoHooks } from './commondao/common.dao.model';
-import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveMethod, CommonDBSaveOptions, CommonDBStreamOptions, DBDeleteByIdsOperation, DBModelType, DBOperation, DBRelation, DBSaveBatchOperation, RunQueryResult } from './db.model';
-import { CommonKeyValueDao, CommonKeyValueDaoCfg } from './kv/commonKeyValueDao';
-import { CommonKeyValueDB, KeyValueDBTuple } from './kv/commonKeyValueDB';
-import { createdUpdatedFields, createdUpdatedIdFields, deserializeJsonField, serializeJsonField } from './model.util';
-import { dbPipelineBackup, DBPipelineBackupOptions } from './pipeline/dbPipelineBackup';
-import { dbPipelineCopy, DBPipelineCopyOptions } from './pipeline/dbPipelineCopy';
-import { dbPipelineRestore, DBPipelineRestoreOptions } from './pipeline/dbPipelineRestore';
-import { DBQuery, DBQueryFilter, DBQueryFilterOperator, dbQueryFilterOperatorValues, DBQueryOrder, RunnableDBQuery } from './query/dbQuery';
-import { DBTransaction, RunnableDBTransaction } from './transaction/dbTransaction';
-import { commitDBTransactionSimple, mergeDBOperations } from './transaction/dbTransaction.util';
+export * from './adapter/inmemory/inMemory.db';
+export * from './adapter/inmemory/inMemoryKeyValueDB';
+export * from './adapter/inmemory/queryInMemory';
+export * from './base.common.db';
+export * from './cnst';
+export * from './common.db';
+export * from './commondao/common.dao';
+export * from './commondao/common.dao.model';
+export * from './db.model';
+export * from './kv/commonKeyValueDao';
+export * from './kv/commonKeyValueDB';
+export * from './model.util';
+export * from './pipeline/dbPipelineBackup';
+export * from './pipeline/dbPipelineCopy';
+export * from './pipeline/dbPipelineRestore';
+export * from './query/dbQuery';
+export * from './transaction/dbTransaction';
+export * from './transaction/dbTransaction.util';
 export * from './kv/commonKeyValueDaoMemoCache';
-export type { DBQueryFilterOperator, DBQueryFilter, DBQueryOrder, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDaoHooks, CommonDBOptions, CommonDBSaveOptions, CommonDBSaveMethod, CommonDBStreamOptions, CommonDBCreateOptions, CommonDB, RunQueryResult, CommonDaoCfg, InMemoryDBCfg, InMemoryKeyValueDBCfg, DBPipelineBackupOptions, DBPipelineRestoreOptions, DBPipelineCopyOptions, DBOperation, DBSaveBatchOperation, DBDeleteByIdsOperation, CommonKeyValueDB, CommonKeyValueDaoCfg, KeyValueDBTuple, };
-export { DBQuery, dbQueryFilterOperatorValues, RunnableDBQuery, CommonDaoLogLevel, DBRelation, DBModelType, CommonDao, createdUpdatedFields, createdUpdatedIdFields, InMemoryDB, InMemoryKeyValueDB, queryInMemory, serializeJsonField, deserializeJsonField, dbPipelineBackup, dbPipelineRestore, dbPipelineCopy, DBLibError, BaseCommonDB, DBTransaction, RunnableDBTransaction, mergeDBOperations, commitDBTransactionSimple, CommonKeyValueDao, };

package/dist/index.js

@@ -1,45 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommonKeyValueDao = exports.commitDBTransactionSimple = exports.mergeDBOperations = exports.RunnableDBTransaction = exports.DBTransaction = exports.BaseCommonDB = exports.DBLibError = exports.dbPipelineCopy = exports.dbPipelineRestore = exports.dbPipelineBackup = exports.deserializeJsonField = exports.serializeJsonField = exports.queryInMemory = exports.InMemoryKeyValueDB = exports.InMemoryDB = exports.createdUpdatedIdFields = exports.createdUpdatedFields = exports.CommonDao = exports.DBModelType = exports.DBRelation = exports.CommonDaoLogLevel = exports.RunnableDBQuery = exports.dbQueryFilterOperatorValues = exports.DBQuery = void 0;
 const tslib_1 = require("tslib");
-const inMemory_db_1 = require("./adapter/inmemory/inMemory.db");
-Object.defineProperty(exports, "InMemoryDB", { enumerable: true, get: function () { return inMemory_db_1.InMemoryDB; } });
-const inMemoryKeyValueDB_1 = require("./adapter/inmemory/inMemoryKeyValueDB");
-Object.defineProperty(exports, "InMemoryKeyValueDB", { enumerable: true, get: function () { return inMemoryKeyValueDB_1.InMemoryKeyValueDB; } });
-const queryInMemory_1 = require("./adapter/inmemory/queryInMemory");
-Object.defineProperty(exports, "queryInMemory", { enumerable: true, get: function () { return queryInMemory_1.queryInMemory; } });
-const base_common_db_1 = require("./base.common.db");
-Object.defineProperty(exports, "BaseCommonDB", { enumerable: true, get: function () { return base_common_db_1.BaseCommonDB; } });
-const cnst_1 = require("./cnst");
-Object.defineProperty(exports, "DBLibError", { enumerable: true, get: function () { return cnst_1.DBLibError; } });
-const common_dao_1 = require("./commondao/common.dao");
-Object.defineProperty(exports, "CommonDao", { enumerable: true, get: function () { return common_dao_1.CommonDao; } });
-const common_dao_model_1 = require("./commondao/common.dao.model");
-Object.defineProperty(exports, "CommonDaoLogLevel", { enumerable: true, get: function () { return common_dao_model_1.CommonDaoLogLevel; } });
-const db_model_1 = require("./db.model");
-Object.defineProperty(exports, "DBModelType", { enumerable: true, get: function () { return db_model_1.DBModelType; } });
-Object.defineProperty(exports, "DBRelation", { enumerable: true, get: function () { return db_model_1.DBRelation; } });
-const commonKeyValueDao_1 = require("./kv/commonKeyValueDao");
-Object.defineProperty(exports, "CommonKeyValueDao", { enumerable: true, get: function () { return commonKeyValueDao_1.CommonKeyValueDao; } });
-const model_util_1 = require("./model.util");
-Object.defineProperty(exports, "createdUpdatedFields", { enumerable: true, get: function () { return model_util_1.createdUpdatedFields; } });
-Object.defineProperty(exports, "createdUpdatedIdFields", { enumerable: true, get: function () { return model_util_1.createdUpdatedIdFields; } });
-Object.defineProperty(exports, "deserializeJsonField", { enumerable: true, get: function () { return model_util_1.deserializeJsonField; } });
-Object.defineProperty(exports, "serializeJsonField", { enumerable: true, get: function () { return model_util_1.serializeJsonField; } });
-const dbPipelineBackup_1 = require("./pipeline/dbPipelineBackup");
-Object.defineProperty(exports, "dbPipelineBackup", { enumerable: true, get: function () { return dbPipelineBackup_1.dbPipelineBackup; } });
-const dbPipelineCopy_1 = require("./pipeline/dbPipelineCopy");
-Object.defineProperty(exports, "dbPipelineCopy", { enumerable: true, get: function () { return dbPipelineCopy_1.dbPipelineCopy; } });
-const dbPipelineRestore_1 = require("./pipeline/dbPipelineRestore");
-Object.defineProperty(exports, "dbPipelineRestore", { enumerable: true, get: function () { return dbPipelineRestore_1.dbPipelineRestore; } });
-const dbQuery_1 = require("./query/dbQuery");
-Object.defineProperty(exports, "DBQuery", { enumerable: true, get: function () { return dbQuery_1.DBQuery; } });
-Object.defineProperty(exports, "dbQueryFilterOperatorValues", { enumerable: true, get: function () { return dbQuery_1.dbQueryFilterOperatorValues; } });
-Object.defineProperty(exports, "RunnableDBQuery", { enumerable: true, get: function () { return dbQuery_1.RunnableDBQuery; } });
-const dbTransaction_1 = require("./transaction/dbTransaction");
-Object.defineProperty(exports, "DBTransaction", { enumerable: true, get: function () { return dbTransaction_1.DBTransaction; } });
-Object.defineProperty(exports, "RunnableDBTransaction", { enumerable: true, get: function () { return dbTransaction_1.RunnableDBTransaction; } });
-const dbTransaction_util_1 = require("./transaction/dbTransaction.util");
-Object.defineProperty(exports, "commitDBTransactionSimple", { enumerable: true, get: function () { return dbTransaction_util_1.commitDBTransactionSimple; } });
-Object.defineProperty(exports, "mergeDBOperations", { enumerable: true, get: function () { return dbTransaction_util_1.mergeDBOperations; } });
+tslib_1.__exportStar(require("./adapter/inmemory/inMemory.db"), exports);
+tslib_1.__exportStar(require("./adapter/inmemory/inMemoryKeyValueDB"), exports);
+tslib_1.__exportStar(require("./adapter/inmemory/queryInMemory"), exports);
+tslib_1.__exportStar(require("./base.common.db"), exports);
+tslib_1.__exportStar(require("./cnst"), exports);
+tslib_1.__exportStar(require("./common.db"), exports);
+tslib_1.__exportStar(require("./commondao/common.dao"), exports);
+tslib_1.__exportStar(require("./commondao/common.dao.model"), exports);
+tslib_1.__exportStar(require("./db.model"), exports);
+tslib_1.__exportStar(require("./kv/commonKeyValueDao"), exports);
+tslib_1.__exportStar(require("./kv/commonKeyValueDB"), exports);
+tslib_1.__exportStar(require("./model.util"), exports);
+tslib_1.__exportStar(require("./pipeline/dbPipelineBackup"), exports);
+tslib_1.__exportStar(require("./pipeline/dbPipelineCopy"), exports);
+tslib_1.__exportStar(require("./pipeline/dbPipelineRestore"), exports);
+tslib_1.__exportStar(require("./query/dbQuery"), exports);
+tslib_1.__exportStar(require("./transaction/dbTransaction"), exports);
+tslib_1.__exportStar(require("./transaction/dbTransaction.util"), exports);
 tslib_1.__exportStar(require("./kv/commonKeyValueDaoMemoCache"), exports);

package/dist/testing/daoTest.js

@@ -21,7 +21,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
     // tableSchemas = true,
     createTable = true, dbQueryFilter = true, 
     // dbQueryFilterIn = true,
-    dbQueryOrder = true, dbQuerySelectFields = true, streaming = true, strongConsistency = true, nullValues = true, } = features;
+    dbQueryOrder = true, dbQuerySelectFields = true, streaming = true, strongConsistency = true, nullValues = true, transactions = true, } = features;
     // const {
     // allowExtraPropertiesInResponse,
     // allowBooleansAsUndefined,
@@ -191,5 +191,46 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
             await db.deleteByIds(test_model_1.TEST_TABLE, rows.map(i => i.id));
         });
     }
+    if (transactions) {
+        test('transaction happy path', async () => {
+            // cleanup
+            await dao.query().deleteByQuery();
+            // Test that id, created, updated are created
+            const now = (0, js_lib_1.localTime)().unix();
+            await dao.runInTransaction([dao.tx.save((0, js_lib_1._omit)(item1, ['id', 'created', 'updated']))]);
+            const loaded = await dao.query().runQuery();
+            expect(loaded.length).toBe(1);
+            expect(loaded[0].id).toBeDefined();
+            expect(loaded[0].created).toBeGreaterThanOrEqual(now);
+            expect(loaded[0].updated).toBe(loaded[0].created);
+            await dao.runInTransaction([dao.tx.deleteById(loaded[0].id)]);
+            // saveBatch [item1, 2, 3]
+            // save item3 with k1: k1_mod
+            // delete item2
+            // remaining: item1, item3_with_k1_mod
+            await dao.runInTransaction([
+                dao.tx.saveBatch(items),
+                dao.tx.save({ ...items[2], k1: 'k1_mod' }),
+                dao.tx.deleteById(items[1].id),
+            ]);
+            const rows = await dao.query().runQuery();
+            const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
+            (0, dbTest_1.expectMatch)(expected, rows, quirks);
+        });
+        test('transaction rollback', async () => {
+            await expect(dao.runInTransaction([
+                dao.tx.deleteById(items[2].id),
+                dao.tx.save({ ...items[0], k1: 5 }), // it should fail here
+            ])).rejects.toThrow();
+            const rows = await dao.query().runQuery();
+            const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
+            (0, dbTest_1.expectMatch)(expected, rows, quirks);
+        });
+        if (querying) {
+            test('transaction cleanup', async () => {
+                await dao.query().deleteByQuery();
+            });
+        }
+    }
 }
 exports.runCommonDaoTest = runCommonDaoTest;

package/dist/testing/dbTest.d.ts

@@ -25,6 +25,7 @@ export interface CommonDBImplementationFeatures {
      * they will return `null` for all missing properties.
      */
     documentDB?: boolean;
+    transactions?: boolean;
 }
 /**
  * All options default to `false`.

package/dist/testing/dbTest.js

@@ -4,6 +4,7 @@ exports.expectMatch = exports.runCommonDBTest = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const dbQuery_1 = require("../query/dbQuery");
+const dbTransaction_1 = require("../transaction/dbTransaction");
 const test_model_1 = require("./test.model");
 const test_util_1 = require("./test.util");
 /**
@@ -12,7 +13,7 @@ const test_util_1 = require("./test.util");
 function runCommonDBTest(db, features = {}, quirks = {}) {
     const { querying = true, tableSchemas = true, createTable = true, dbQueryFilter = true, 
     // dbQueryFilterIn = true,
-    dbQueryOrder = true, dbQuerySelectFields = true, insert = true, update = true, streaming = true, strongConsistency = true, bufferSupport = true, nullValues = true, documentDB = true, } = features;
+    dbQueryOrder = true, dbQuerySelectFields = true, insert = true, update = true, streaming = true, strongConsistency = true, bufferSupport = true, nullValues = true, documentDB = true, transactions = true, } = features;
     // const {
     // allowExtraPropertiesInResponse,
     // allowBooleansAsUndefined,
@@ -95,6 +96,9 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
     test('saveBatch test items', async () => {
         await db.saveBatch(test_model_1.TEST_TABLE, items);
     });
+    test('saveBatch should throw on null id', async () => {
+        await expect(db.saveBatch(test_model_1.TEST_TABLE, [{ ...item1, id: null }])).rejects.toThrow();
+    });
     if (insert) {
         test('saveBatch INSERT method should throw', async () => {
             await expect(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'insert' })).rejects.toThrow();
@@ -169,11 +173,11 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
     // getTables
     test('getTables, getTableSchema (if supported)', async () => {
         const tables = await db.getTables();
-        console.log({ tables });
+        // console.log({ tables })
         if (tableSchemas) {
             await (0, js_lib_1.pMap)(tables, async (table) => {
                 const schema = await db.getTableSchema(table);
-                console.log(schema);
+                // console.log(schema)
                 expect(schema.$id).toBe(`${table}.schema.json`);
             });
         }
@@ -201,18 +205,46 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             await db.saveBatch(test_model_1.TEST_TABLE, [item]);
             const [loaded] = await db.getByIds(test_model_1.TEST_TABLE, [item.id]);
             const b1Loaded = loaded.b1;
-            console.log({
-                b11: typeof b1,
-                b12: typeof b1Loaded,
-                l1: b1.length,
-                l2: b1Loaded.length,
-                b1,
-                b1Loaded,
-            });
+            // console.log({
+            //   b11: typeof b1,
+            //   b12: typeof b1Loaded,
+            //   l1: b1.length,
+            //   l2: b1Loaded.length,
+            //   b1,
+            //   b1Loaded,
+            // })
             expect(b1Loaded).toEqual(b1);
             expect(b1Loaded.toString()).toBe(s);
         });
     }
+    if (transactions) {
+        test('transaction happy path', async () => {
+            // cleanup
+            await db.deleteByQuery(queryAll());
+            // saveBatch [item1, 2, 3]
+            // save item3 with k1: k1_mod
+            // delete item2
+            // remaining: item1, item3_with_k1_mod
+            const tx = dbTransaction_1.DBTransaction.create()
+                .saveBatch(test_model_1.TEST_TABLE, items)
+                .save(test_model_1.TEST_TABLE, { ...items[2], k1: 'k1_mod' })
+                .deleteById(test_model_1.TEST_TABLE, items[1].id);
+            await db.commitTransaction(tx);
+            const { rows } = await db.runQuery(queryAll());
+            const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
+            expectMatch(expected, rows, quirks);
+        });
+        test('transaction rollback', async () => {
+            // It should fail on id == null
+            const tx = dbTransaction_1.DBTransaction.create()
+                .deleteById(test_model_1.TEST_TABLE, items[2].id)
+                .save(test_model_1.TEST_TABLE, { ...items[0], k1: 5, id: null });
+            await expect(db.commitTransaction(tx)).rejects.toThrow();
+            const { rows } = await db.runQuery(queryAll());
+            const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
+            expectMatch(expected, rows, quirks);
+        });
+    }
     if (querying) {
         test('cleanup', async () => {
             // CLEAN UP

package/dist/timeseries/commonTimeSeriesDao.js

@@ -42,7 +42,7 @@ class CommonTimeSeriesDao {
     async commitTransaction(ops) {
         if (!ops.length)
             return;
-        const tx = new __1.DBTransaction();
+        const tx = __1.DBTransaction.create();
         ops.forEach(op => {
             const rows = op.dataPoints.map(([ts, v]) => ({
                 id: String(ts),

package/dist/transaction/dbTransaction.d.ts

@@ -6,7 +6,14 @@ import type { CommonDBSaveOptions, DBOperation } from '../db.model';
  */
 export declare class DBTransaction {
     ops: DBOperation[];
+    protected constructor(ops?: DBOperation[]);
+    /**
+     * Convenience method.
+     */
+    static create(ops?: DBOperation[]): DBTransaction;
+    save<ROW extends ObjectWithId = AnyObjectWithId>(table: string, row: ROW): this;
     saveBatch<ROW extends ObjectWithId = AnyObjectWithId>(table: string, rows: ROW[]): this;
+    deleteById(table: string, id: string): this;
     deleteByIds(table: string, ids: string[]): this;
 }
 /**