@naturalcycles/db-lib 10.0.2 → 10.1.1

package/dist/pipeline/dbPipelineRestore.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dbPipelineRestore = dbPipelineRestore;
-const js_lib_1 = require("@naturalcycles/js-lib");
-const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
+import { _hb, _mapValues, _passthroughMapper, ErrorMode, localTime, pMap, } from '@naturalcycles/js-lib';
+import { _pipeline, boldWhite, dimWhite, fs2, grey, NDJsonStats, transformChunk, transformFilterSync, transformLogProgress, transformMap, transformTap, writableForEach, yellow, } from '@naturalcycles/nodejs-lib';
 /**
  * Pipeline from NDJSON files in a folder (optionally gzipped) to CommonDB.
  * Allows to define a mapper and a predicate to map/filter objects between input and output.
@@ -10,17 +7,17 @@ const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
  *
  * Optionally you can provide mapperPerTable and @param transformMapOptions (one for all mappers) - it will run for each table.
  */
-async function dbPipelineRestore(opt) {
-    const { db, concurrency = 16, chunkSize = 100, limit, sinceUpdated, inputDirPath, mapperPerTable = {}, saveOptionsPerTable = {}, transformMapOptions, errorMode = js_lib_1.ErrorMode.SUPPRESS, recreateTables = false, } = opt;
+export async function dbPipelineRestore(opt) {
+    const { db, concurrency = 16, chunkSize = 100, limit, sinceUpdated, inputDirPath, mapperPerTable = {}, saveOptionsPerTable = {}, transformMapOptions, errorMode = ErrorMode.SUPPRESS, recreateTables = false, } = opt;
     const onlyTables = opt.tables && new Set(opt.tables);
-    const sinceUpdatedStr = sinceUpdated ? ' since ' + (0, nodejs_lib_1.grey)((0, js_lib_1.localTime)(sinceUpdated).toPretty()) : '';
-    console.log(`>> ${(0, nodejs_lib_1.dimWhite)('dbPipelineRestore')} started in ${(0, nodejs_lib_1.grey)(inputDirPath)}...${sinceUpdatedStr}`);
-    nodejs_lib_1.fs2.ensureDir(inputDirPath);
+    const sinceUpdatedStr = sinceUpdated ? ' since ' + grey(localTime(sinceUpdated).toPretty()) : '';
+    console.log(`>> ${dimWhite('dbPipelineRestore')} started in ${grey(inputDirPath)}...${sinceUpdatedStr}`);
+    fs2.ensureDir(inputDirPath);
     const tablesToGzip = new Set();
     const sizeByTable = {};
     const statsPerTable = {};
     const tables = [];
-    nodejs_lib_1.fs2.readdir(inputDirPath).forEach(f => {
+    fs2.readdir(inputDirPath).forEach(f => {
         let table;
         let gzip = false;
         if (f.endsWith('.ndjson')) {
@@ -38,61 +35,61 @@ async function dbPipelineRestore(opt) {
         tables.push(table);
         if (gzip)
             tablesToGzip.add(table);
-        sizeByTable[table] = nodejs_lib_1.fs2.stat(`${inputDirPath}/${f}`).size;
+        sizeByTable[table] = fs2.stat(`${inputDirPath}/${f}`).size;
     });
-    const sizeStrByTable = (0, js_lib_1._mapValues)(sizeByTable, (_k, b) => (0, js_lib_1._hb)(b));
-    console.log(`${(0, nodejs_lib_1.yellow)(tables.length)} ${(0, nodejs_lib_1.boldWhite)('table(s)')}:\n`, sizeStrByTable);
+    const sizeStrByTable = _mapValues(sizeByTable, (_k, b) => _hb(b));
+    console.log(`${yellow(tables.length)} ${boldWhite('table(s)')}:\n`, sizeStrByTable);
     // const schemaByTable: Record<string, CommonSchema> = {}
     if (recreateTables) {
-        await (0, js_lib_1.pMap)(tables, async (table) => {
+        await pMap(tables, async (table) => {
             const schemaFilePath = `${inputDirPath}/${table}.schema.json`;
-            if (!nodejs_lib_1.fs2.pathExists(schemaFilePath)) {
+            if (!fs2.pathExists(schemaFilePath)) {
                 console.warn(`${schemaFilePath} does not exist!`);
                 return;
             }
-            const schema = await nodejs_lib_1.fs2.readJsonAsync(schemaFilePath);
+            const schema = await fs2.readJsonAsync(schemaFilePath);
             await db.createTable(table, schema, { dropIfExists: true });
         });
     }
-    await (0, js_lib_1.pMap)(tables, async (table) => {
+    await pMap(tables, async (table) => {
         const gzip = tablesToGzip.has(table);
         const filePath = `${inputDirPath}/${table}.ndjson` + (gzip ? '.gz' : '');
         const saveOptions = saveOptionsPerTable[table] || {};
         const started = Date.now();
         let rows = 0;
         const sizeBytes = sizeByTable[table];
-        console.log(`<< ${(0, nodejs_lib_1.grey)(filePath)} ${(0, nodejs_lib_1.dimWhite)((0, js_lib_1._hb)(sizeBytes))} started...`);
-        await (0, nodejs_lib_1._pipeline)([
-            nodejs_lib_1.fs2.createReadStreamAsNDJSON(filePath).take(limit || Number.POSITIVE_INFINITY),
-            (0, nodejs_lib_1.transformTap)(() => rows++),
-            (0, nodejs_lib_1.transformLogProgress)({
+        console.log(`<< ${grey(filePath)} ${dimWhite(_hb(sizeBytes))} started...`);
+        await _pipeline([
+            fs2.createReadStreamAsNDJSON(filePath).take(limit || Number.POSITIVE_INFINITY),
+            transformTap(() => rows++),
+            transformLogProgress({
                 logEvery: 1000,
                 ...opt,
                 metric: table,
             }),
             ...(sinceUpdated
-                ? [(0, nodejs_lib_1.transformFilterSync)(r => r.updated >= sinceUpdated)]
+                ? [transformFilterSync(r => r.updated >= sinceUpdated)]
                 : []),
-            (0, nodejs_lib_1.transformMap)(mapperPerTable[table] || js_lib_1._passthroughMapper, {
+            transformMap(mapperPerTable[table] || _passthroughMapper, {
                 errorMode,
                 flattenArrayOutput: true,
                 ...transformMapOptions,
                 metric: table,
             }),
-            (0, nodejs_lib_1.transformChunk)({ chunkSize }),
-            (0, nodejs_lib_1.writableForEach)(async (dbms) => {
+            transformChunk({ chunkSize }),
+            writableForEach(async (dbms) => {
                 await db.saveBatch(table, dbms, saveOptions);
             }),
         ]);
-        const stats = nodejs_lib_1.NDJsonStats.create({
+        const stats = NDJsonStats.create({
             tookMillis: Date.now() - started,
             rows,
             sizeBytes,
         });
-        console.log(`<< ${(0, nodejs_lib_1.grey)(filePath)}\n` + stats.toPretty());
+        console.log(`<< ${grey(filePath)}\n` + stats.toPretty());
         statsPerTable[table] = stats;
     }, { concurrency, errorMode });
-    const statsTotal = nodejs_lib_1.NDJsonStats.createCombined(Object.values(statsPerTable));
+    const statsTotal = NDJsonStats.createCombined(Object.values(statsPerTable));
     console.log(statsTotal.toPretty('total'));
     return statsTotal;
 }

package/dist/query/dbQuery.d.ts

@@ -1,8 +1,8 @@
 import type { AsyncMapper, BaseDBEntity, ObjectWithId } from '@naturalcycles/js-lib';
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import type { CommonDaoOptions, CommonDaoReadOptions, CommonDaoStreamDeleteOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions } from '..';
-import type { CommonDao } from '../commondao/common.dao';
-import type { RunQueryResult } from '../db.model';
+import type { CommonDao } from '../commondao/common.dao.js';
+import type { CommonDaoOptions, CommonDaoReadOptions, CommonDaoStreamDeleteOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions } from '../commondao/common.dao.model.js';
+import type { RunQueryResult } from '../db.model.js';
 /**
  * Modeled after Firestore operators (WhereFilterOp type)
  *

package/dist/query/dbQuery.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnableDBQuery = exports.DBQuery = exports.dbQueryFilterOperatorValues = void 0;
-const js_lib_1 = require("@naturalcycles/js-lib");
-exports.dbQueryFilterOperatorValues = [
+import { _objectAssign, _truncate } from '@naturalcycles/js-lib';
+export const dbQueryFilterOperatorValues = [
     '<',
     '<=',
     '==',
@@ -24,7 +21,7 @@ exports.dbQueryFilterOperatorValues = [
  *
  * <DBM> is the type of **queried** object (so e.g `key of DBM` can be used), not **returned** object.
  */
-class DBQuery {
+export class DBQuery {
     table;
     constructor(table) {
         this.table = table;
@@ -102,7 +99,7 @@ class DBQuery {
         return this;
     }
     clone() {
-        return (0, js_lib_1._objectAssign)(new DBQuery(this.table), {
+        return _objectAssign(new DBQuery(this.table), {
             _filters: [...this._filters],
             _limitValue: this._limitValue,
             _offsetValue: this._offsetValue,
@@ -136,19 +133,18 @@ class DBQuery {
             tokens.push(`limit ${this._limitValue}`);
         }
         if (this._startCursor) {
-            tokens.push(`startCursor ${(0, js_lib_1._truncate)(this._startCursor, 8)}`);
+            tokens.push(`startCursor ${_truncate(this._startCursor, 8)}`);
         }
         if (this._endCursor) {
-            tokens.push(`endCursor ${(0, js_lib_1._truncate)(this._endCursor, 8)}`);
+            tokens.push(`endCursor ${_truncate(this._endCursor, 8)}`);
         }
         return tokens;
     }
 }
-exports.DBQuery = DBQuery;
 /**
  * DBQuery that has additional method to support Fluent API style.
  */
-class RunnableDBQuery extends DBQuery {
+export class RunnableDBQuery extends DBQuery {
     dao;
     /**
      * Pass `table` to override table.
@@ -203,4 +199,3 @@ class RunnableDBQuery extends DBQuery {
         return await this.dao.deleteByQuery(this, opt);
     }
 }
-exports.RunnableDBQuery = RunnableDBQuery;

package/dist/testing/{dbTest.d.ts → commonDBTest.d.ts}

@@ -1,4 +1,4 @@
-import type { CommonDB } from '../common.db';
+import type { CommonDB } from '../common.db.js';
 /**
  * All options default to `false`.
  */

package/dist/testing/{dbTest.js → commonDBTest.js}

@@ -1,25 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCommonDBTest = runCommonDBTest;
-const js_lib_1 = require("@naturalcycles/js-lib");
-const common_db_1 = require("../common.db");
-const dbQuery_1 = require("../query/dbQuery");
-const test_model_1 = require("./test.model");
-async function runCommonDBTest(db, quirks = {}) {
+import { _deepFreeze, _filterObject, _pick, _sortBy, localTime, pMap } from '@naturalcycles/js-lib';
+import { CommonDBType } from '../common.db.js';
+import { DBQuery } from '../query/dbQuery.js';
+import { createTestItemDBM, createTestItemsDBM, TEST_TABLE, testItemBMJsonSchema, } from './test.model.js';
+export async function runCommonDBTest(db, quirks = {}) {
     // this is because vitest cannot be "required" from cjs
     const { test, expect } = await import('vitest');
     const { support } = db;
-    const items = (0, test_model_1.createTestItemsDBM)(3);
-    (0, js_lib_1._deepFreeze)(items);
+    const items = createTestItemsDBM(3);
+    _deepFreeze(items);
     const item1 = items[0];
-    const queryAll = () => dbQuery_1.DBQuery.create(test_model_1.TEST_TABLE);
+    const queryAll = () => DBQuery.create(TEST_TABLE);
     test('ping', async () => {
         await db.ping();
     });
     // CREATE TABLE, DROP
     if (support.createTable) {
         test('createTable, dropIfExists=true', async () => {
-            await db.createTable(test_model_1.TEST_TABLE, test_model_1.testItemBMJsonSchema, { dropIfExists: true });
+            await db.createTable(TEST_TABLE, testItemBMJsonSchema, { dropIfExists: true });
         });
     }
     if (support.queries) {
@@ -36,21 +33,21 @@ async function runCommonDBTest(db, quirks = {}) {
     }
     // GET empty
     test('getByIds(item1.id) should return empty', async () => {
-        const [item1Loaded] = await db.getByIds(test_model_1.TEST_TABLE, [item1.id]);
+        const [item1Loaded] = await db.getByIds(TEST_TABLE, [item1.id]);
         // console.log(a)
         expect(item1Loaded).toBeUndefined();
     });
     test('getByIds([]) should return []', async () => {
-        expect(await db.getByIds(test_model_1.TEST_TABLE, [])).toEqual([]);
+        expect(await db.getByIds(TEST_TABLE, [])).toEqual([]);
     });
     test('getByIds(...) should return empty', async () => {
-        expect(await db.getByIds(test_model_1.TEST_TABLE, ['abc', 'abcd'])).toEqual([]);
+        expect(await db.getByIds(TEST_TABLE, ['abc', 'abcd'])).toEqual([]);
     });
     // TimeMachine
     if (support.timeMachine) {
         test('getByIds(...) 10 minutes ago should return []', async () => {
-            expect(await db.getByIds(test_model_1.TEST_TABLE, [item1.id, 'abc'], {
-                readAt: js_lib_1.localTime.now().minus(10, 'minute').unix,
+            expect(await db.getByIds(TEST_TABLE, [item1.id, 'abc'], {
+                readAt: localTime.now().minus(10, 'minute').unix,
             })).toEqual([]);
         });
     }
@@ -58,27 +55,27 @@ async function runCommonDBTest(db, quirks = {}) {
     if (support.nullValues) {
         test('should allow to save and load null values', async () => {
             const item3 = {
-                ...(0, test_model_1.createTestItemDBM)(3),
+                ...createTestItemDBM(3),
                 k2: null,
             };
-            (0, js_lib_1._deepFreeze)(item3);
-            await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
-            const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
+            _deepFreeze(item3);
+            await db.saveBatch(TEST_TABLE, [item3]);
+            const item3Loaded = (await db.getByIds(TEST_TABLE, [item3.id]))[0];
             expectMatch([item3], [item3Loaded], quirks);
             expect(item3Loaded.k2).toBeNull();
         });
     }
-    if (db.dbType === common_db_1.CommonDBType.document) {
+    if (db.dbType === CommonDBType.document) {
         test('undefined values should not be saved/loaded', async () => {
             const item3 = {
-                ...(0, test_model_1.createTestItemDBM)(3),
+                ...createTestItemDBM(3),
                 k2: undefined,
             };
-            (0, js_lib_1._deepFreeze)(item3);
+            _deepFreeze(item3);
             const expected = { ...item3 };
             delete expected.k2;
-            await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
-            const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
+            await db.saveBatch(TEST_TABLE, [item3]);
+            const item3Loaded = (await db.getByIds(TEST_TABLE, [item3.id]))[0];
             expectMatch([expected], [item3Loaded], quirks);
             expect(item3Loaded.k2).toBeUndefined();
             expect(Object.keys(item3Loaded)).not.toContain('k2');
@@ -86,81 +83,81 @@ async function runCommonDBTest(db, quirks = {}) {
     }
     if (support.updateSaveMethod) {
         test('saveBatch UPDATE method should throw', async () => {
-            await expect(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'update' })).rejects.toThrow();
+            await expect(db.saveBatch(TEST_TABLE, items, { saveMethod: 'update' })).rejects.toThrow();
         });
     }
     test('saveBatch test items', async () => {
-        await db.saveBatch(test_model_1.TEST_TABLE, items);
+        await db.saveBatch(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();
+        await expect(db.saveBatch(TEST_TABLE, [{ ...item1, id: null }])).rejects.toThrow();
     });
     if (support.insertSaveMethod) {
         test('saveBatch INSERT method should throw', async () => {
-            await expect(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'insert' })).rejects.toThrow();
+            await expect(db.saveBatch(TEST_TABLE, items, { saveMethod: 'insert' })).rejects.toThrow();
         });
     }
     if (support.updateSaveMethod) {
         test('saveBatch UPDATE method should pass', async () => {
-            await db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'update' });
+            await db.saveBatch(TEST_TABLE, items, { saveMethod: 'update' });
         });
     }
     // GET not empty
     test('getByIds all items', async () => {
-        const rows = await db.getByIds(test_model_1.TEST_TABLE, items.map(i => i.id).concat('abcd'));
-        expectMatch(items, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
+        const rows = await db.getByIds(TEST_TABLE, items.map(i => i.id).concat('abcd'));
+        expectMatch(items, _sortBy(rows, r => r.id), quirks);
     });
     // QUERY
     if (support.queries) {
         test('runQuery(all) should return all items', async () => {
             let { rows } = await db.runQuery(queryAll());
-            rows = (0, js_lib_1._sortBy)(rows, r => r.id); // because query doesn't specify order here
+            rows = _sortBy(rows, r => r.id); // because query doesn't specify order here
             expectMatch(items, rows, quirks);
         });
         if (support.dbQueryFilter) {
             test('query even=true', async () => {
-                const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).filter('even', '==', true);
+                const q = new DBQuery(TEST_TABLE).filter('even', '==', true);
                 let { rows } = await db.runQuery(q);
                 if (!support.dbQueryOrder)
-                    rows = (0, js_lib_1._sortBy)(rows, r => r.id);
+                    rows = _sortBy(rows, r => r.id);
                 expectMatch(items.filter(i => i.even), rows, quirks);
             });
         }
         if (support.dbQueryOrder) {
             test('query order by k1 desc', async () => {
-                const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).order('k1', true);
+                const q = new DBQuery(TEST_TABLE).order('k1', true);
                 const { rows } = await db.runQuery(q);
                 expectMatch([...items].reverse(), rows, quirks);
             });
         }
         if (support.dbQuerySelectFields) {
             test('projection query with only ids', async () => {
-                const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).select(['id']);
+                const q = new DBQuery(TEST_TABLE).select(['id']);
                 let { rows } = await db.runQuery(q);
-                rows = (0, js_lib_1._sortBy)(rows, r => r.id); // cause order is not specified
-                expectMatch(items.map(item => (0, js_lib_1._pick)(item, ['id'])), rows, quirks);
+                rows = _sortBy(rows, r => r.id); // cause order is not specified
+                expectMatch(items.map(item => _pick(item, ['id'])), rows, quirks);
             });
             test('projection query without ids', async () => {
-                const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).select(['k1']);
+                const q = new DBQuery(TEST_TABLE).select(['k1']);
                 let { rows } = await db.runQuery(q);
-                rows = (0, js_lib_1._sortBy)(rows, r => r.k1); // cause order is not specified
-                expectMatch(items.map(item => (0, js_lib_1._pick)(item, ['k1'])), rows, quirks);
+                rows = _sortBy(rows, r => r.k1); // cause order is not specified
+                expectMatch(items.map(item => _pick(item, ['k1'])), rows, quirks);
             });
             test('projection query empty fields (edge case)', async () => {
-                const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).select([]);
+                const q = new DBQuery(TEST_TABLE).select([]);
                 const { rows } = await db.runQuery(q);
                 expectMatch(items.map(() => ({})), rows, quirks);
             });
         }
         test('runQueryCount should return 3', async () => {
-            expect(await db.runQueryCount(new dbQuery_1.DBQuery(test_model_1.TEST_TABLE))).toBe(3);
+            expect(await db.runQueryCount(new DBQuery(TEST_TABLE))).toBe(3);
         });
     }
     // STREAM
     if (support.streaming) {
         test('streamQuery all', async () => {
             let rows = await db.streamQuery(queryAll()).toArray();
-            rows = (0, js_lib_1._sortBy)(rows, r => r.id); // cause order is not specified in DBQuery
+            rows = _sortBy(rows, r => r.id); // cause order is not specified in DBQuery
             expectMatch(items, rows, quirks);
         });
     }
@@ -169,7 +166,7 @@ async function runCommonDBTest(db, quirks = {}) {
         const tables = await db.getTables();
         // console.log({ tables })
         if (support.tableSchemas) {
-            await (0, js_lib_1.pMap)(tables, async (table) => {
+            await pMap(tables, async (table) => {
                 const schema = await db.getTableSchema(table);
                 // console.log(schema)
                 expect(schema.$id).toBe(`${table}.schema.json`);
@@ -179,7 +176,7 @@ async function runCommonDBTest(db, quirks = {}) {
     // DELETE BY
     if (support.queries && support.dbQueryFilter) {
         test('deleteByQuery even=false', async () => {
-            const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).filter('even', '==', false);
+            const q = new DBQuery(TEST_TABLE).filter('even', '==', false);
             const deleted = await db.deleteByQuery(q);
             expect(deleted).toBe(items.filter(item => !item.even).length);
             expect(await db.runQueryCount(queryAll())).toBe(1);
@@ -191,11 +188,11 @@ async function runCommonDBTest(db, quirks = {}) {
             const s = 'helloWorld 1';
             const b1 = Buffer.from(s);
             const item = {
-                ...(0, test_model_1.createTestItemDBM)(1),
+                ...createTestItemDBM(1),
                 b1,
             };
-            await db.saveBatch(test_model_1.TEST_TABLE, [item]);
-            const loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item.id]))[0];
+            await db.saveBatch(TEST_TABLE, [item]);
+            const loaded = (await db.getByIds(TEST_TABLE, [item.id]))[0];
             const b1Loaded = loaded.b1;
             // console.log({
             //   b11: typeof b1,
@@ -210,6 +207,16 @@ async function runCommonDBTest(db, quirks = {}) {
         });
     }
     if (support.transactions) {
+        /**
+         * Returns expected items in the DB after the preparation.
+         */
+        async function prepare() {
+            // cleanup
+            await db.deleteByQuery(queryAll());
+            const itemsToSave = [items[0], { ...items[2], k1: 'k1_mod' }];
+            await db.saveBatch(TEST_TABLE, itemsToSave);
+            return itemsToSave;
+        }
         test('transaction happy path', async () => {
             // cleanup
             await db.deleteByQuery(queryAll());
@@ -218,21 +225,34 @@ async function runCommonDBTest(db, quirks = {}) {
             // delete item2
             // remaining: item1, item3_with_k1_mod
             await db.runInTransaction(async (tx) => {
-                await tx.saveBatch(test_model_1.TEST_TABLE, items);
-                await tx.saveBatch(test_model_1.TEST_TABLE, [{ ...items[2], k1: 'k1_mod' }]);
-                await tx.deleteByIds(test_model_1.TEST_TABLE, [items[1].id]);
+                await tx.saveBatch(TEST_TABLE, items);
+                await tx.saveBatch(TEST_TABLE, [{ ...items[2], k1: 'k1_mod' }]);
+                await tx.deleteByIds(TEST_TABLE, [items[1].id]);
             });
             const { rows } = await db.runQuery(queryAll());
             const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
             expectMatch(expected, rows, quirks);
         });
+        test('createTransaction happy path', async () => {
+            // cleanup
+            await db.deleteByQuery(queryAll());
+            const tx = await db.createTransaction();
+            await tx.saveBatch(TEST_TABLE, items);
+            await tx.saveBatch(TEST_TABLE, [{ ...items[2], k1: 'k1_mod' }]);
+            await tx.deleteByIds(TEST_TABLE, [items[1].id]);
+            await tx.commit();
+            const { rows } = await db.runQuery(queryAll());
+            const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
+            expectMatch(expected, rows, quirks);
+        });
         test('transaction rollback', async () => {
+            const expected = await prepare();
             let err;
             try {
                 await db.runInTransaction(async (tx) => {
-                    await tx.deleteByIds(test_model_1.TEST_TABLE, [items[2].id]);
+                    await tx.deleteByIds(TEST_TABLE, [items[2].id]);
                     // It should fail on id == null
-                    await tx.saveBatch(test_model_1.TEST_TABLE, [{ ...items[0], k1: 5, id: null }]);
+                    await tx.saveBatch(TEST_TABLE, [{ ...items[0], k1: 5, id: null }]);
                 });
             }
             catch (err_) {
@@ -240,7 +260,6 @@ async function runCommonDBTest(db, quirks = {}) {
             }
             expect(err).toBeDefined();
             const { rows } = await db.runQuery(queryAll());
-            const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
             expectMatch(expected, rows, quirks);
         });
     }
@@ -248,12 +267,12 @@ async function runCommonDBTest(db, quirks = {}) {
         test('patchByQuery', async () => {
             // cleanup, reset initial data
             await db.deleteByQuery(queryAll());
-            await db.saveBatch(test_model_1.TEST_TABLE, items);
+            await db.saveBatch(TEST_TABLE, items);
             const patch = {
                 k3: 5,
                 k2: 'abc',
             };
-            await db.patchByQuery(dbQuery_1.DBQuery.create(test_model_1.TEST_TABLE).filterEq('even', true), patch);
+            await db.patchByQuery(DBQuery.create(TEST_TABLE).filterEq('even', true), patch);
             const { rows } = await db.runQuery(queryAll());
             const expected = items.map(r => {
                 if (r.even) {
@@ -268,8 +287,8 @@ async function runCommonDBTest(db, quirks = {}) {
         test('incrementBatch', async () => {
             // cleanup, reset initial data
             await db.deleteByQuery(queryAll());
-            await db.saveBatch(test_model_1.TEST_TABLE, items);
-            await db.incrementBatch(test_model_1.TEST_TABLE, 'k3', { id1: 1, id2: 2 });
+            await db.saveBatch(TEST_TABLE, items);
+            await db.incrementBatch(TEST_TABLE, 'k3', { id1: 1, id2: 2 });
             const { rows } = await db.runQuery(queryAll());
             const expected = items.map(r => {
                 if (r.id === 'id1') {
@@ -294,7 +313,7 @@ async function runCommonDBTest(db, quirks = {}) {
         // const actualSorted = sortObjectDeep(actual)
         if (quirks.allowBooleansAsUndefined) {
             expected = expected.map(r => {
-                return typeof r !== 'object' ? r : (0, js_lib_1._filterObject)(r, (_k, v) => v !== false);
+                return typeof r !== 'object' ? r : _filterObject(r, (_k, v) => v !== false);
             });
         }
         if (quirks.allowExtraPropertiesInResponse) {

package/dist/testing/commonDaoTest.d.ts

@@ -0,0 +1,3 @@
+import type { CommonDB } from '../common.db.js';
+import type { CommonDBImplementationQuirks } from './commonDBTest.js';
+export declare function runCommonDaoTest(db: CommonDB, quirks?: CommonDBImplementationQuirks): Promise<void>;