@naturalcycles/db-lib 10.0.2 → 10.1.1

package/dist/commondao/common.dao.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommonDaoTransaction = exports.CommonDao = void 0;
-const js_lib_1 = require("@naturalcycles/js-lib");
-const index_js_1 = require("@naturalcycles/js-lib/dist/zod/index.js");
-const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
-const cnst_1 = require("../cnst");
-const dbQuery_1 = require("../query/dbQuery");
-const common_dao_model_1 = require("./common.dao.model");
+import { _assert, _deepCopy, _deepJsonEquals, _filterUndefinedValues, _isTruthy, _objectAssignExact, _passthroughPredicate, _since, _truncate, _typeCast, _uniqBy, AppError, ErrorMode, localTime, pMap, SKIP, } from '@naturalcycles/js-lib';
+import { ZodSchema, zSafeValidate } from '@naturalcycles/js-lib/dist/zod/index.js';
+import { _pipeline, AjvSchema, getValidationResult, stringId, transformChunk, transformLogProgress, transformMap, transformNoOp, writableVoid, } from '@naturalcycles/nodejs-lib';
+import { DBLibError } from '../cnst.js';
+import { RunnableDBQuery } from '../query/dbQuery.js';
+import { CommonDaoLogLevel } from './common.dao.model.js';
 const isGAE = !!process.env['GAE_INSTANCE'];
 const isCI = !!process.env['CI'];
 /**
@@ -16,7 +13,7 @@ const isCI = !!process.env['CI'];
  * BM = Backend model (optimized for API access)
  * TM = Transport model (optimized to be sent over the wire)
  */
-class CommonDao {
+export class CommonDao {
     cfg;
     constructor(cfg) {
         this.cfg = cfg;
@@ -24,7 +21,7 @@ class CommonDao {
             // Default is to NOT log in AppEngine and in CI,
             // otherwise to log Operations
             // e.g in Dev (local machine), Test - it will log operations (useful for debugging)
-            logLevel: isGAE || isCI ? common_dao_model_1.CommonDaoLogLevel.NONE : common_dao_model_1.CommonDaoLogLevel.OPERATIONS,
+            logLevel: isGAE || isCI ? CommonDaoLogLevel.NONE : CommonDaoLogLevel.OPERATIONS,
             generateId: true,
             assignGeneratedIds: false,
             useCreatedProperty: true,
@@ -42,7 +39,7 @@ class CommonDao {
             },
         };
         if (this.cfg.generateId) {
-            this.cfg.hooks.createRandomId ||= () => (0, nodejs_lib_1.stringId)();
+            this.cfg.hooks.createRandomId ||= () => stringId();
         }
         else {
             delete this.cfg.hooks.createRandomId;
@@ -98,12 +95,12 @@ class CommonDao {
     async getByIds(ids, opt = {}) {
         if (!ids.length)
             return [];
-        const op = `getByIds ${ids.length} id(s) (${(0, js_lib_1._truncate)(ids.slice(0, 10).join(', '), 50)})`;
+        const op = `getByIds ${ids.length} id(s) (${_truncate(ids.slice(0, 10).join(', '), 50)})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
         let dbms = await (opt.tx || this.cfg.db).getByIds(table, ids, opt);
         if (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);
+            dbms = (await pMap(dbms, async (dbm) => await this.cfg.hooks.afterLoad(dbm))).filter(_isTruthy);
         }
         const bms = await this.dbmsToBM(dbms, opt);
         this.logResult(started, op, bms, table);
@@ -112,12 +109,12 @@ class CommonDao {
     async getByIdsAsDBM(ids, opt = {}) {
         if (!ids.length)
             return [];
-        const op = `getByIdsAsDBM ${ids.length} id(s) (${(0, js_lib_1._truncate)(ids.slice(0, 10).join(', '), 50)})`;
+        const op = `getByIdsAsDBM ${ids.length} id(s) (${_truncate(ids.slice(0, 10).join(', '), 50)})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
         let dbms = await (opt.tx || this.cfg.db).getByIds(table, ids, opt);
         if (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);
+            dbms = (await pMap(dbms, async (dbm) => await this.cfg.hooks.afterLoad(dbm))).filter(_isTruthy);
         }
         this.logResult(started, op, dbms, table);
         return dbms;
@@ -138,7 +135,7 @@ class CommonDao {
     }
     throwRequiredError(id, opt) {
         const table = opt.table || this.cfg.table;
-        throw new js_lib_1.AppError(`DB row required, but not found in ${table}`, {
+        throw new AppError(`DB row required, but not found in ${table}`, {
             table,
             id,
         });
@@ -148,7 +145,7 @@ class CommonDao {
      */
     requireWriteAccess() {
         if (this.cfg.readOnly) {
-            throw new js_lib_1.AppError(cnst_1.DBLibError.DAO_IS_READ_ONLY, {
+            throw new AppError(DBLibError.DAO_IS_READ_ONLY, {
                 table: this.cfg.table,
             });
         }
@@ -158,7 +155,7 @@ class CommonDao {
      */
     requireObjectMutability(opt) {
         if (this.cfg.immutable && !opt.allowMutability) {
-            throw new js_lib_1.AppError(cnst_1.DBLibError.OBJECT_IS_IMMUTABLE, {
+            throw new AppError(DBLibError.OBJECT_IS_IMMUTABLE, {
                 table: this.cfg.table,
             });
         }
@@ -167,7 +164,7 @@ class CommonDao {
         // todo: retry N times
         const existing = await this.cfg.db.getByIds(table, [dbm.id]);
         if (existing.length) {
-            throw new js_lib_1.AppError(cnst_1.DBLibError.NON_UNIQUE_ID, {
+            throw new AppError(DBLibError.NON_UNIQUE_ID, {
                 table,
                 ids: existing.map(i => i.id),
             });
@@ -188,14 +185,14 @@ class CommonDao {
      * Pass `table` to override table
      */
     query(table) {
-        return new dbQuery_1.RunnableDBQuery(this, table);
+        return new RunnableDBQuery(this, table);
     }
     async runQuery(q, opt) {
         const { rows } = await this.runQueryExtended(q, opt);
         return rows;
     }
     async runQuerySingleColumn(q, opt) {
-        (0, js_lib_1._assert)(q._selectedFieldNames?.length === 1, `runQuerySingleColumn requires exactly 1 column to be selected: ${q.pretty()}`);
+        _assert(q._selectedFieldNames?.length === 1, `runQuerySingleColumn requires exactly 1 column to be selected: ${q.pretty()}`);
         const col = q._selectedFieldNames[0];
         const { rows } = await this.runQueryExtended(q, opt);
         return rows.map((r) => r[col]);
@@ -206,8 +203,8 @@ class CommonDao {
      * Order is not guaranteed, as queries run in parallel.
      */
     async runUnionQueries(queries, opt) {
-        const results = (await (0, js_lib_1.pMap)(queries, async (q) => (await this.runQueryExtended(q, opt)).rows)).flat();
-        return (0, js_lib_1._uniqBy)(results, r => r.id);
+        const results = (await pMap(queries, async (q) => (await this.runQueryExtended(q, opt)).rows)).flat();
+        return _uniqBy(results, r => r.id);
     }
     async runQueryExtended(q, opt = {}) {
         this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
@@ -217,7 +214,7 @@ class CommonDao {
         let { rows, ...queryResult } = await this.cfg.db.runQuery(q, opt);
         const partialQuery = !!q._selectedFieldNames;
         if (this.cfg.hooks.afterLoad && rows.length) {
-            rows = (await (0, js_lib_1.pMap)(rows, async (dbm) => await this.cfg.hooks.afterLoad(dbm))).filter(js_lib_1._isTruthy);
+            rows = (await pMap(rows, async (dbm) => await this.cfg.hooks.afterLoad(dbm))).filter(_isTruthy);
         }
         const bms = partialQuery ? rows : await this.dbmsToBM(rows, opt);
         this.logResult(started, op, bms, q.table);
@@ -237,7 +234,7 @@ class CommonDao {
         const started = this.logStarted(op, q.table);
         let { rows, ...queryResult } = await this.cfg.db.runQuery(q, opt);
         if (this.cfg.hooks.afterLoad && rows.length) {
-            rows = (await (0, js_lib_1.pMap)(rows, async (dbm) => await this.cfg.hooks.afterLoad(dbm))).filter(js_lib_1._isTruthy);
+            rows = (await pMap(rows, async (dbm) => await this.cfg.hooks.afterLoad(dbm))).filter(_isTruthy);
         }
         const partialQuery = !!q._selectedFieldNames;
         const dbms = partialQuery ? rows : this.anyToDBMs(rows, opt);
@@ -250,8 +247,8 @@ class CommonDao {
         const op = `runQueryCount(${q.pretty()})`;
         const started = this.logStarted(op, q.table);
         const count = await this.cfg.db.runQueryCount(q, opt);
-        if (this.cfg.logLevel >= common_dao_model_1.CommonDaoLogLevel.OPERATIONS) {
-            this.cfg.logger?.log(`<< ${q.table}.${op}: ${count} row(s) in ${(0, js_lib_1._since)(started)}`);
+        if (this.cfg.logLevel >= CommonDaoLogLevel.OPERATIONS) {
+            this.cfg.logger?.log(`<< ${q.table}.${op}: ${count} row(s) in ${_since(started)}`);
         }
         return count;
     }
@@ -259,78 +256,78 @@ class CommonDao {
         this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         opt.skipValidation = opt.skipValidation !== false; // default true
-        opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
+        opt.errorMode ||= ErrorMode.SUPPRESS;
         const partialQuery = !!q._selectedFieldNames;
         const op = `streamQueryForEach(${q.pretty()})`;
         const started = this.logStarted(op, q.table, true);
         let count = 0;
-        await (0, nodejs_lib_1._pipeline)([
+        await _pipeline([
             this.cfg.db.streamQuery(q, opt),
-            (0, nodejs_lib_1.transformMap)(async (dbm) => {
+            transformMap(async (dbm) => {
                 count++;
                 if (partialQuery)
                     return dbm;
                 if (this.cfg.hooks.afterLoad) {
                     dbm = (await this.cfg.hooks.afterLoad(dbm));
                     if (dbm === null)
-                        return js_lib_1.SKIP;
+                        return SKIP;
                 }
                 return await this.dbmToBM(dbm, opt);
             }, {
                 errorMode: opt.errorMode,
             }),
-            (0, nodejs_lib_1.transformMap)(mapper, {
+            transformMap(mapper, {
                 ...opt,
-                predicate: js_lib_1._passthroughPredicate, // to be able to logProgress
+                predicate: _passthroughPredicate, // to be able to logProgress
             }),
             // LogProgress should be AFTER the mapper, to be able to report correct stats
-            (0, nodejs_lib_1.transformLogProgress)({
+            transformLogProgress({
                 metric: q.table,
                 ...opt,
             }),
-            (0, nodejs_lib_1.writableVoid)(),
+            writableVoid(),
         ]);
-        if (this.cfg.logLevel >= common_dao_model_1.CommonDaoLogLevel.OPERATIONS) {
-            this.cfg.logger?.log(`<< ${q.table}.${op}: ${count} row(s) in ${(0, js_lib_1._since)(started)}`);
+        if (this.cfg.logLevel >= CommonDaoLogLevel.OPERATIONS) {
+            this.cfg.logger?.log(`<< ${q.table}.${op}: ${count} row(s) in ${_since(started)}`);
         }
     }
     async streamQueryAsDBMForEach(q, mapper, opt = {}) {
         this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         opt.skipValidation = opt.skipValidation !== false; // default true
-        opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
+        opt.errorMode ||= ErrorMode.SUPPRESS;
         const partialQuery = !!q._selectedFieldNames;
         const op = `streamQueryAsDBMForEach(${q.pretty()})`;
         const started = this.logStarted(op, q.table, true);
         let count = 0;
-        await (0, nodejs_lib_1._pipeline)([
+        await _pipeline([
             this.cfg.db.streamQuery(q, opt),
-            (0, nodejs_lib_1.transformMap)(async (dbm) => {
+            transformMap(async (dbm) => {
                 count++;
                 if (partialQuery)
                     return dbm;
                 if (this.cfg.hooks.afterLoad) {
                     dbm = (await this.cfg.hooks.afterLoad(dbm));
                     if (dbm === null)
-                        return js_lib_1.SKIP;
+                        return SKIP;
                 }
                 return this.anyToDBM(dbm, opt);
             }, {
                 errorMode: opt.errorMode,
             }),
-            (0, nodejs_lib_1.transformMap)(mapper, {
+            transformMap(mapper, {
                 ...opt,
-                predicate: js_lib_1._passthroughPredicate, // to be able to logProgress
+                predicate: _passthroughPredicate, // to be able to logProgress
             }),
             // LogProgress should be AFTER the mapper, to be able to report correct stats
-            (0, nodejs_lib_1.transformLogProgress)({
+            transformLogProgress({
                 metric: q.table,
                 ...opt,
             }),
-            (0, nodejs_lib_1.writableVoid)(),
+            writableVoid(),
         ]);
-        if (this.cfg.logLevel >= common_dao_model_1.CommonDaoLogLevel.OPERATIONS) {
-            this.cfg.logger?.log(`<< ${q.table}.${op}: ${count} row(s) in ${(0, js_lib_1._since)(started)}`);
+        if (this.cfg.logLevel >= CommonDaoLogLevel.OPERATIONS) {
+            this.cfg.logger?.log(`<< ${q.table}.${op}: ${count} row(s) in ${_since(started)}`);
         }
     }
     /**
@@ -340,18 +337,18 @@ class CommonDao {
         this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         opt.skipValidation = opt.skipValidation !== false; // default true
-        opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
+        opt.errorMode ||= ErrorMode.SUPPRESS;
         const partialQuery = !!q._selectedFieldNames;
         const stream = this.cfg.db.streamQuery(q, opt);
         if (partialQuery)
             return stream;
         return stream
             .on('error', err => stream.emit('error', err))
-            .pipe((0, nodejs_lib_1.transformMap)(async (dbm) => {
+            .pipe(transformMap(async (dbm) => {
             if (this.cfg.hooks.afterLoad) {
                 dbm = (await this.cfg.hooks.afterLoad(dbm));
                 if (dbm === null)
-                    return js_lib_1.SKIP;
+                    return SKIP;
             }
             return this.anyToDBM(dbm, opt);
         }, {
@@ -371,7 +368,7 @@ class CommonDao {
         this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         opt.skipValidation = opt.skipValidation !== false; // default true
-        opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
+        opt.errorMode ||= ErrorMode.SUPPRESS;
         const stream = this.cfg.db.streamQuery(q, opt);
         const partialQuery = !!q._selectedFieldNames;
         if (partialQuery)
@@ -392,11 +389,11 @@ class CommonDao {
             // .pipe(transformMap<any, DBM>(dbm => this.anyToDBM(dbm, opt), safeOpt))
             // .pipe(transformMap<DBM, BM>(dbm => this.dbmToBM(dbm, opt), safeOpt))
             .on('error', err => stream.emit('error', err))
-            .pipe((0, nodejs_lib_1.transformMap)(async (dbm) => {
+            .pipe(transformMap(async (dbm) => {
             if (this.cfg.hooks.afterLoad) {
                 dbm = (await this.cfg.hooks.afterLoad(dbm));
                 if (dbm === null)
-                    return js_lib_1.SKIP;
+                    return SKIP;
             }
             return await this.dbmToBM(dbm, opt);
         }, {
@@ -406,7 +403,7 @@ class CommonDao {
             // but not applying it now for perf reasons
             // UPD: applying, to be compliant with `.toArray()`, etc.
             .on('error', err => stream.emit('error', err))
-            .pipe((0, nodejs_lib_1.transformNoOp)()));
+            .pipe(transformNoOp()));
     }
     async queryIds(q, opt = {}) {
         this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
@@ -417,7 +414,7 @@ class CommonDao {
     streamQueryIds(q, opt = {}) {
         this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
-        opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
+        opt.errorMode ||= ErrorMode.SUPPRESS;
         // Experimental: using `.map()`
         const stream = this.cfg.db
             .streamQuery(q.select(['id']), opt)
@@ -436,28 +433,28 @@ class CommonDao {
     async streamQueryIdsForEach(q, mapper, opt = {}) {
         this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
-        opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
+        opt.errorMode ||= ErrorMode.SUPPRESS;
         const op = `streamQueryIdsForEach(${q.pretty()})`;
         const started = this.logStarted(op, q.table, true);
         let count = 0;
-        await (0, nodejs_lib_1._pipeline)([
+        await _pipeline([
             this.cfg.db.streamQuery(q.select(['id']), opt).map(r => {
                 count++;
                 return r.id;
             }),
-            (0, nodejs_lib_1.transformMap)(mapper, {
+            transformMap(mapper, {
                 ...opt,
-                predicate: js_lib_1._passthroughPredicate,
+                predicate: _passthroughPredicate,
             }),
             // LogProgress should be AFTER the mapper, to be able to report correct stats
-            (0, nodejs_lib_1.transformLogProgress)({
+            transformLogProgress({
                 metric: q.table,
                 ...opt,
             }),
-            (0, nodejs_lib_1.writableVoid)(),
+            writableVoid(),
         ]);
-        if (this.cfg.logLevel >= common_dao_model_1.CommonDaoLogLevel.OPERATIONS) {
-            this.cfg.logger?.log(`<< ${q.table}.${op}: ${count} id(s) in ${(0, js_lib_1._since)(started)}`);
+        if (this.cfg.logLevel >= CommonDaoLogLevel.OPERATIONS) {
+            this.cfg.logger?.log(`<< ${q.table}.${op}: ${count} id(s) in ${_since(started)}`);
         }
     }
     /**
@@ -465,7 +462,7 @@ class CommonDao {
      * "Returns", just to have a type of "Saved"
      */
     assignIdCreatedUpdated(obj, opt = {}) {
-        const now = js_lib_1.localTime.nowUnix();
+        const now = localTime.nowUnix();
         if (this.cfg.useCreatedProperty) {
             obj.created ||= obj.updated || now;
         }
@@ -504,14 +501,14 @@ class CommonDao {
         });
         if (loaded) {
             patched = { ...loaded, ...patch };
-            if ((0, js_lib_1._deepJsonEquals)(loaded, patched)) {
+            if (_deepJsonEquals(loaded, patched)) {
                 // Skipping the save operation, as data is the same
                 return patched;
             }
         }
         else {
             const table = opt.table || this.cfg.table;
-            (0, js_lib_1._assert)(opt.createIfMissing, `DB row required, but not found in ${table}`, {
+            _assert(opt.createIfMissing, `DB row required, but not found in ${table}`, {
                 id,
                 table,
             });
@@ -545,7 +542,7 @@ class CommonDao {
                 ...bm,
                 ...patch,
             };
-            if ((0, js_lib_1._deepJsonEquals)(bm, patched)) {
+            if (_deepJsonEquals(bm, patched)) {
                 // Skipping the save operation, as data is the same
                 return bm;
             }
@@ -563,8 +560,8 @@ class CommonDao {
                 ...patch,
             };
             // Make `bm` exactly the same as `loadedWithPatch`
-            (0, js_lib_1._objectAssignExact)(bm, loadedWithPatch);
-            if ((0, js_lib_1._deepJsonEquals)(loaded, loadedWithPatch)) {
+            _objectAssignExact(bm, loadedWithPatch);
+            if (_deepJsonEquals(loaded, loadedWithPatch)) {
                 // Skipping the save operation, as data is the same
                 return bm;
             }
@@ -589,14 +586,14 @@ class CommonDao {
             // which should be removed post-validation, but it breaks the "equality check"
             // Post-validation the equality check should work as intended
             const convertedBM = this.validateAndConvert(bm, this.cfg.bmSchema, 'save', opt);
-            if ((0, js_lib_1._deepJsonEquals)(convertedBM, opt.skipIfEquals)) {
+            if (_deepJsonEquals(convertedBM, opt.skipIfEquals)) {
                 // Skipping the save operation
                 return bm;
             }
         }
         const idWasGenerated = !bm.id && this.cfg.generateId;
         this.assignIdCreatedUpdated(bm, opt); // mutates
-        (0, js_lib_1._typeCast)(bm);
+        _typeCast(bm);
         let dbm = await this.bmToDBM(bm, opt); // validates BM
         if (this.cfg.hooks.beforeSave) {
             dbm = (await this.cfg.hooks.beforeSave(dbm));
@@ -665,14 +662,14 @@ class CommonDao {
         bms.forEach(bm => this.assignIdCreatedUpdated(bm, opt));
         let dbms = await this.bmsToDBM(bms, opt);
         if (this.cfg.hooks.beforeSave && dbms.length) {
-            dbms = (await (0, js_lib_1.pMap)(dbms, async (dbm) => await this.cfg.hooks.beforeSave(dbm))).filter(js_lib_1._isTruthy);
+            dbms = (await pMap(dbms, async (dbm) => await this.cfg.hooks.beforeSave(dbm))).filter(_isTruthy);
         }
         if (opt.ensureUniqueId)
-            throw new js_lib_1.AppError('ensureUniqueId is not supported in saveBatch');
+            throw new AppError('ensureUniqueId is not supported in saveBatch');
         if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
             opt = { ...opt, saveMethod: 'insert' };
         }
-        const op = `saveBatch ${dbms.length} row(s) (${(0, js_lib_1._truncate)(dbms
+        const op = `saveBatch ${dbms.length} row(s) (${_truncate(dbms
             .slice(0, 10)
             .map(bm => bm.id)
             .join(', '), 50)})`;
@@ -698,11 +695,11 @@ class CommonDao {
         dbms.forEach(dbm => this.assignIdCreatedUpdated(dbm, opt)); // mutates
         let rows = this.anyToDBMs(dbms, opt);
         if (opt.ensureUniqueId)
-            throw new js_lib_1.AppError('ensureUniqueId is not supported in saveBatch');
+            throw new AppError('ensureUniqueId is not supported in saveBatch');
         if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
             opt = { ...opt, saveMethod: 'insert' };
         }
-        const op = `saveBatchAsDBM ${rows.length} row(s) (${(0, js_lib_1._truncate)(rows
+        const op = `saveBatchAsDBM ${rows.length} row(s) (${_truncate(rows
             .slice(0, 10)
             .map(bm => bm.id)
             .join(', '), 50)})`;
@@ -710,7 +707,7 @@ class CommonDao {
         const { excludeFromIndexes } = this.cfg;
         const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds;
         if (this.cfg.hooks.beforeSave && rows.length) {
-            rows = (await (0, js_lib_1.pMap)(rows, async (row) => await this.cfg.hooks.beforeSave(row))).filter(js_lib_1._isTruthy);
+            rows = (await pMap(rows, async (row) => await this.cfg.hooks.beforeSave(row))).filter(_isTruthy);
         }
         await (opt.tx || this.cfg.db).saveBatch(table, rows, {
             excludeFromIndexes,
@@ -733,7 +730,7 @@ class CommonDao {
         this.requireWriteAccess();
         const table = opt.table || this.cfg.table;
         opt.skipValidation ??= true;
-        opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
+        opt.errorMode ||= ErrorMode.SUPPRESS;
         if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
             opt = { ...opt, saveMethod: 'insert' };
         }
@@ -741,20 +738,20 @@ class CommonDao {
         const { beforeSave } = this.cfg.hooks;
         const { chunkSize = 500, chunkConcurrency = 32, errorMode } = opt;
         return [
-            (0, nodejs_lib_1.transformMap)(async (bm) => {
+            transformMap(async (bm) => {
                 this.assignIdCreatedUpdated(bm, opt); // mutates
                 let dbm = await this.bmToDBM(bm, opt);
                 if (beforeSave) {
                     dbm = (await beforeSave(dbm));
                     if (dbm === null)
-                        return js_lib_1.SKIP;
+                        return SKIP;
                 }
                 return dbm;
             }, {
                 errorMode,
             }),
-            (0, nodejs_lib_1.transformChunk)({ chunkSize }),
-            (0, nodejs_lib_1.transformMap)(async (batch) => {
+            transformChunk({ chunkSize }),
+            transformMap(async (batch) => {
                 await this.cfg.db.saveBatch(table, batch, {
                     ...opt,
                     excludeFromIndexes,
@@ -765,13 +762,13 @@ class CommonDao {
                 errorMode,
                 flattenArrayOutput: true,
             }),
-            (0, nodejs_lib_1.transformLogProgress)({
+            transformLogProgress({
                 metric: 'saved',
                 ...opt,
             }),
             // just to satisfy and simplify typings
             // It's easier to return Transform[], rather than (Transform | Writable)[]
-            (0, nodejs_lib_1.writableVoid)(),
+            writableVoid(),
         ];
     }
     // DELETE
@@ -810,24 +807,24 @@ class CommonDao {
         let deleted = 0;
         if (opt.chunkSize) {
             const { chunkSize, chunkConcurrency = 32 } = opt;
-            await (0, nodejs_lib_1._pipeline)([
+            await _pipeline([
                 this.cfg.db.streamQuery(q.select(['id']), opt).map(r => r.id),
-                (0, nodejs_lib_1.transformChunk)({ chunkSize }),
-                (0, nodejs_lib_1.transformMap)(async (ids) => {
+                transformChunk({ chunkSize }),
+                transformMap(async (ids) => {
                     await this.cfg.db.deleteByIds(q.table, ids, opt);
                     deleted += ids.length;
                 }, {
-                    predicate: js_lib_1._passthroughPredicate,
+                    predicate: _passthroughPredicate,
                     concurrency: chunkConcurrency,
                 }),
                 // LogProgress should be AFTER the mapper, to be able to report correct stats
-                (0, nodejs_lib_1.transformLogProgress)({
+                transformLogProgress({
                     metric: q.table,
                     logEvery: 2, // 500 * 2 === 1000
                     chunkSize,
                     ...opt,
                 }),
-                (0, nodejs_lib_1.writableVoid)(),
+                writableVoid(),
             ]);
         }
         else {
@@ -899,7 +896,7 @@ class CommonDao {
         return this.validateAndConvert(bm, this.cfg.bmSchema, 'load', opt);
     }
     async dbmsToBM(dbms, opt = {}) {
-        return await (0, js_lib_1.pMap)(dbms, async (dbm) => await this.dbmToBM(dbm, opt));
+        return await pMap(dbms, async (dbm) => await this.dbmToBM(dbm, opt));
     }
     async bmToDBM(bm, opt) {
         if (bm === undefined)
@@ -911,7 +908,7 @@ class CommonDao {
     }
     async bmsToDBM(bms, opt = {}) {
         // try/catch?
-        return await (0, js_lib_1.pMap)(bms, async (bm) => await this.bmToDBM(bm, opt));
+        return await pMap(bms, async (bm) => await this.bmToDBM(bm, opt));
     }
     anyToDBM(dbm, opt = {}) {
         if (!dbm)
@@ -947,7 +944,7 @@ class CommonDao {
         // obj = _filterNullishValues(obj as any)
         // We still filter `undefined` values here, because `beforeDBMToBM` can return undefined values
         // and they can be annoying with snapshot tests
-        obj = (0, js_lib_1._filterUndefinedValues)(obj);
+        obj = _filterUndefinedValues(obj);
         // Return as is if no schema is passed or if `skipConversion` is set
         if (!schema ||
             opt.skipValidation ||
@@ -960,13 +957,13 @@ class CommonDao {
         const objectName = table;
         let error;
         let convertedValue;
-        if (schema instanceof index_js_1.ZodSchema) {
+        if (schema instanceof ZodSchema) {
             // Zod schema
-            const vr = (0, index_js_1.zSafeValidate)(obj, schema);
+            const vr = zSafeValidate(obj, schema);
             error = vr.error;
             convertedValue = vr.data;
         }
-        else if (schema instanceof nodejs_lib_1.AjvSchema) {
+        else if (schema instanceof AjvSchema) {
             // Ajv schema
             convertedValue = obj; // because Ajv mutates original object
             error = schema.getValidationError(obj, {
@@ -975,9 +972,9 @@ class CommonDao {
         }
         else {
             // Joi
-            const start = js_lib_1.localTime.nowUnixMillis();
-            const vr = (0, nodejs_lib_1.getValidationResult)(obj, schema, objectName);
-            const tookMillis = js_lib_1.localTime.nowUnixMillis() - start;
+            const start = localTime.nowUnixMillis();
+            const vr = getValidationResult(obj, schema, objectName);
+            const tookMillis = localTime.nowUnixMillis() - start;
             this.cfg.onValidationTime?.({
                 tookMillis,
                 table,
@@ -1007,6 +1004,10 @@ class CommonDao {
     async ping() {
         await this.cfg.db.ping();
     }
+    async createTransaction(opt) {
+        const tx = await this.cfg.db.createTransaction(opt);
+        return new CommonDaoTransaction(tx, this.cfg.logger);
+    }
     async runInTransaction(fn, opt) {
         let r;
         await this.cfg.db.runInTransaction(async (tx) => {
@@ -1029,7 +1030,7 @@ class CommonDao {
         if (!excludeFromIndexes)
             return;
         for (const f of q._filters) {
-            (0, js_lib_1._assert)(!excludeFromIndexes.includes(f.name), `cannot query on non-indexed property: ${this.cfg.table}.${f.name}`, {
+            _assert(!excludeFromIndexes.includes(f.name), `cannot query on non-indexed property: ${this.cfg.table}.${f.name}`, {
                 query: q.pretty(),
             });
         }
@@ -1041,37 +1042,37 @@ class CommonDao {
         const args = [];
         if (Array.isArray(res)) {
             logRes = `${res.length} row(s)`;
-            if (res.length && this.cfg.logLevel >= common_dao_model_1.CommonDaoLogLevel.DATA_FULL) {
+            if (res.length && this.cfg.logLevel >= CommonDaoLogLevel.DATA_FULL) {
                 args.push('\n', ...res.slice(0, 10)); // max 10 items
             }
         }
         else if (res) {
             logRes = `1 row`;
-            if (this.cfg.logLevel >= common_dao_model_1.CommonDaoLogLevel.DATA_SINGLE) {
+            if (this.cfg.logLevel >= CommonDaoLogLevel.DATA_SINGLE) {
                 args.push('\n', res);
             }
         }
         else {
             logRes = `undefined`;
         }
-        this.cfg.logger?.log(`<< ${table}.${op}: ${logRes} in ${(0, js_lib_1._since)(started)}`, ...args);
+        this.cfg.logger?.log(`<< ${table}.${op}: ${logRes} in ${_since(started)}`, ...args);
     }
     logSaveResult(started, op, table) {
         if (!this.cfg.logLevel)
             return;
-        this.cfg.logger?.log(`<< ${table}.${op} in ${(0, js_lib_1._since)(started)}`);
+        this.cfg.logger?.log(`<< ${table}.${op} in ${_since(started)}`);
     }
     logStarted(op, table, force = false) {
         if (this.cfg.logStarted || force) {
             this.cfg.logger?.log(`>> ${table}.${op}`);
         }
-        return js_lib_1.localTime.nowUnixMillis();
+        return localTime.nowUnixMillis();
     }
     logSaveStarted(op, items, table) {
         if (this.cfg.logStarted) {
             const args = [`>> ${table}.${op}`];
             if (Array.isArray(items)) {
-                if (items.length && this.cfg.logLevel >= common_dao_model_1.CommonDaoLogLevel.DATA_FULL) {
+                if (items.length && this.cfg.logLevel >= CommonDaoLogLevel.DATA_FULL) {
                     args.push('\n', ...items.slice(0, 10));
                 }
                 else {
@@ -1079,29 +1080,36 @@ class CommonDao {
                 }
             }
             else {
-                if (this.cfg.logLevel >= common_dao_model_1.CommonDaoLogLevel.DATA_SINGLE) {
+                if (this.cfg.logLevel >= CommonDaoLogLevel.DATA_SINGLE) {
                     args.push(items);
                 }
             }
             this.cfg.logger?.log(...args);
         }
-        return js_lib_1.localTime.nowUnixMillis();
+        return localTime.nowUnixMillis();
     }
 }
-exports.CommonDao = CommonDao;
 /**
  * Transaction context.
  * Has similar API than CommonDao, but all operations are performed in the context of the transaction.
  */
-class CommonDaoTransaction {
+export class CommonDaoTransaction {
     tx;
     logger;
     constructor(tx, logger) {
         this.tx = tx;
         this.logger = logger;
     }
+    /**
+     * Commits the underlying DBTransaction.
+     * May throw.
+     */
+    async commit() {
+        await this.tx.commit();
+    }
     /**
      * Perform a graceful rollback without throwing/re-throwing any error.
+     * Never throws.
      */
     async rollback() {
         try {
@@ -1145,7 +1153,7 @@ class CommonDaoTransaction {
      * So, this method is a rather simple convenience "Object.assign and then save".
      */
     async patch(dao, bm, patch, opt) {
-        const skipIfEquals = (0, js_lib_1._deepCopy)(bm);
+        const skipIfEquals = _deepCopy(bm);
         Object.assign(bm, patch);
         return await dao.save(bm, { ...opt, skipIfEquals, tx: this.tx });
     }
@@ -1158,4 +1166,3 @@ class CommonDaoTransaction {
         return await dao.deleteByIds(ids, { ...opt, tx: this.tx });
     }
 }
-exports.CommonDaoTransaction = CommonDaoTransaction;