@naturalcycles/db-lib 8.60.0 → 9.0.0

package/dist/common.db.d.ts

@@ -1,9 +1,35 @@
 import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, DBPatch, RunQueryResult } from './db.model';
+import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, DBPatch, DBTransaction, RunQueryResult } from './db.model';
 import { DBQuery } from './query/dbQuery';
-import { DBTransaction } from './transaction/dbTransaction';
+export declare enum CommonDBType {
+    'document' = "document",
+    'relational' = "relational"
+}
 export interface CommonDB {
+    /**
+     * Relational databases are expected to return `null` for all missing properties.
+     */
+    dbType: CommonDBType;
+    /**
+     * Manifest of supported features.
+     */
+    support: CommonDBSupport;
+    supportsQueries?: boolean;
+    supportsDBQueryFilter?: boolean;
+    supportsDBQueryFilterIn?: boolean;
+    supportsDBQueryOrder?: boolean;
+    supportsDBQuerySelectFields?: boolean;
+    supportsInsertSaveMethod?: boolean;
+    supportsUpdateSaveMethod?: boolean;
+    supportsUpdateByQuery?: boolean;
+    supportsDBIncrement?: boolean;
+    supportsCreateTable?: boolean;
+    supportsTableSchemas?: boolean;
+    supportsStreaming?: boolean;
+    supportsBufferValues?: boolean;
+    supportsNullValues?: boolean;
+    supportsTransactions?: boolean;
     /**
      * Checks that connection/credentials/etc is ok.
      * Also acts as a "warmup request" for a DB.
@@ -31,7 +57,7 @@ export interface CommonDB {
      * Order of items returned is not guaranteed to match order of ids.
      * (Such limitation exists because Datastore doesn't support it).
      */
-    getByIds: <ROW extends ObjectWithId>(table: string, ids: ROW['id'][], opt?: CommonDBOptions) => Promise<ROW[]>;
+    getByIds: <ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions) => Promise<ROW[]>;
     /**
      * Order by 'id' is not supported by all implementations (for example, Datastore doesn't support it).
      */
@@ -42,6 +68,11 @@ export interface CommonDB {
      * rows can have missing ids only if DB supports auto-generating them (like mysql auto_increment).
      */
     saveBatch: <ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>) => Promise<void>;
+    /**
+     * Returns number of deleted items.
+     * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
+     */
+    deleteByIds: (table: string, ids: string[], opt?: CommonDBOptions) => Promise<number>;
     /**
      * Returns number of deleted items.
      * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
@@ -70,5 +101,26 @@ export interface CommonDB {
      * Should be implemented as a Transaction (best effort), which means that
      * either ALL or NONE of the operations should be applied.
      */
-    commitTransaction: (tx: DBTransaction, opt?: CommonDBOptions) => Promise<void>;
+    createTransaction: () => Promise<DBTransaction>;
+}
+/**
+ * Manifest of supported features.
+ */
+export interface CommonDBSupport {
+    queries?: boolean;
+    dbQueryFilter?: boolean;
+    dbQueryFilterIn?: boolean;
+    dbQueryOrder?: boolean;
+    dbQuerySelectFields?: boolean;
+    insertSaveMethod?: boolean;
+    updateSaveMethod?: boolean;
+    updateByQuery?: boolean;
+    dbIncrement?: boolean;
+    createTable?: boolean;
+    tableSchemas?: boolean;
+    streaming?: boolean;
+    bufferValues?: boolean;
+    nullValues?: boolean;
+    transactions?: boolean;
 }
+export declare const commonDBFullSupport: CommonDBSupport;

package/dist/common.db.js

@@ -1,2 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonDBFullSupport = exports.CommonDBType = void 0;
+var CommonDBType;
+(function (CommonDBType) {
+    CommonDBType["document"] = "document";
+    CommonDBType["relational"] = "relational";
+})(CommonDBType || (exports.CommonDBType = CommonDBType = {}));
+exports.commonDBFullSupport = {
+    queries: true,
+    dbQueryFilter: true,
+    dbQueryFilterIn: true,
+    dbQueryOrder: true,
+    dbQuerySelectFields: true,
+    insertSaveMethod: true,
+    updateSaveMethod: true,
+    updateByQuery: true,
+    dbIncrement: true,
+    createTable: true,
+    tableSchemas: true,
+    streaming: true,
+    bufferValues: true,
+    nullValues: true,
+    transactions: true,
+};

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

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 import { Transform } from 'node:stream';
-import { AnyObject, AsyncMapper, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, Promisable, Saved, UnixTimestampMillisNumber, Unsaved, ZodSchema } from '@naturalcycles/js-lib';
+import { AnyObject, AsyncMapper, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, Saved, UnixTimestampMillisNumber, Unsaved, ZodSchema } from '@naturalcycles/js-lib';
 import { AjvSchema, ObjectSchema, ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { DBDeleteByIdsOperation, DBModelType, DBOperation, DBPatch, DBSaveBatchOperation, RunQueryResult } from '../db.model';
+import { DBModelType, DBPatch, DBTransaction, RunQueryResult } from '../db.model';
 import { DBQuery, RunnableDBQuery } from '../query/dbQuery';
 import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveBatchOptions, CommonDaoSaveOptions, CommonDaoStreamDeleteOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDaoStreamSaveOptions } from './common.dao.model';
 /**
@@ -85,12 +85,6 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
     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?: CommonDaoSaveBatchOptions<DBM>) => Promise<DBSaveBatchOperation | undefined>;
-        saveBatch: (bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>) => Promise<DBSaveBatchOperation | undefined>;
-        deleteByIds: (ids: string[], opt?: CommonDaoOptions) => Promise<DBDeleteByIdsOperation | undefined>;
-        deleteById: (id: string | null | undefined, opt?: CommonDaoOptions) => Promise<DBDeleteByIdsOperation | undefined>;
-    };
     /**
      * Mutates with id, created, updated
      */
@@ -175,9 +169,23 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
      * Proxy to this.cfg.db.ping
      */
     ping(): Promise<void>;
-    runInTransaction(ops: Promisable<DBOperation | undefined>[]): Promise<void>;
+    useTransaction(fn: (tx: CommonDaoTransaction) => Promise<void>): Promise<void>;
+    createTransaction(): Promise<CommonDaoTransaction>;
     protected logResult(started: number, op: string, res: any, table: string): void;
     protected logSaveResult(started: number, op: string, table: string): void;
     protected logStarted(op: string, table: string, force?: boolean): UnixTimestampMillisNumber;
     protected logSaveStarted(op: string, items: any, table: string): UnixTimestampMillisNumber;
 }
+export declare class CommonDaoTransaction {
+    private tx;
+    constructor(tx: DBTransaction);
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    getById<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, id: string, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
+    getByIds<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, ids: string[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    runQuery<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    save<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, bm: Unsaved<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    saveBatch<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
+    deleteById(dao: CommonDao<any>, id: string, opt?: CommonDaoOptions): Promise<number>;
+    deleteByIds(dao: CommonDao<any>, ids: string[], opt?: CommonDaoOptions): Promise<number>;
+}

package/dist/commondao/common.dao.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommonDao = void 0;
+exports.CommonDaoTransaction = exports.CommonDao = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 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");
 const isGAE = !!process.env['GAE_INSTANCE'];
 const isCI = !!process.env['CI'];
@@ -20,57 +19,6 @@ const isCI = !!process.env['CI'];
 class CommonDao {
     constructor(cfg) {
         this.cfg = cfg;
-        this.tx = {
-            save: async (bm, opt = {}) => {
-                // .save actually returns DBM (not BM) when it detects `opt.tx === true`
-                const row = (await this.save(bm, { ...opt, tx: true }));
-                if (row === null)
-                    return;
-                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 }));
-                if (!rows.length)
-                    return;
-                return {
-                    type: 'saveBatch',
-                    table: this.cfg.table,
-                    rows,
-                    opt: {
-                        excludeFromIndexes: this.cfg.excludeFromIndexes,
-                        ...opt,
-                    },
-                };
-            },
-            deleteByIds: async (ids, opt = {}) => {
-                if (!ids.length)
-                    return;
-                return {
-                    type: 'deleteByIds',
-                    table: this.cfg.table,
-                    ids,
-                    opt,
-                };
-            },
-            deleteById: async (id, opt = {}) => {
-                if (!id)
-                    return;
-                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
@@ -562,13 +510,9 @@ class CommonDao {
         let dbm = await this.bmToDBM(bm, opt);
         if (this.cfg.hooks.beforeSave) {
             dbm = (await this.cfg.hooks.beforeSave(dbm));
-            if (dbm === null && !opt.tx)
+            if (dbm === null)
                 return bm;
         }
-        if (opt.tx) {
-            // May return `null`, in which case it'll be skipped
-            return dbm;
-        }
         const table = opt.table || this.cfg.table;
         if (opt.ensureUniqueId && idWasGenerated)
             await this.ensureUniqueId(table, dbm);
@@ -706,9 +650,6 @@ class CommonDao {
         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);
         }
-        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) {
@@ -792,7 +733,7 @@ class CommonDao {
                 let dbm = await this.bmToDBM(bm, opt);
                 if (beforeSave) {
                     dbm = (await beforeSave(dbm));
-                    if (dbm === null && !opt.tx)
+                    if (dbm === null)
                         return js_lib_1.SKIP;
                 }
                 return dbm;
@@ -828,7 +769,7 @@ class CommonDao {
         const op = `deleteById(${id})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const count = await this.cfg.db.deleteByQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id));
+        const count = await this.cfg.db.deleteByIds(table, [id], opt);
         this.logSaveResult(started, op, table);
         return count;
     }
@@ -840,7 +781,7 @@ class CommonDao {
         const op = `deleteByIds(${ids.join(', ')})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const count = await this.cfg.db.deleteByQuery(dbQuery_1.DBQuery.create(table).filterIn('id', ids));
+        const count = await this.cfg.db.deleteByIds(table, ids, opt);
         this.logSaveResult(started, op, table);
         return count;
     }
@@ -1050,11 +991,21 @@ class CommonDao {
     async ping() {
         await this.cfg.db.ping();
     }
-    async runInTransaction(ops) {
-        const resolvedOps = (await Promise.all(ops)).filter(js_lib_1._isTruthy);
-        if (!resolvedOps.length)
-            return;
-        await this.cfg.db.commitTransaction(dbTransaction_1.DBTransaction.create(resolvedOps));
+    async useTransaction(fn) {
+        const tx = await this.cfg.db.createTransaction();
+        const daoTx = new CommonDaoTransaction(tx);
+        try {
+            await fn(daoTx);
+            await daoTx.commit();
+        }
+        catch (err) {
+            await daoTx.rollback();
+            throw err;
+        }
+    }
+    async createTransaction() {
+        const tx = await this.cfg.db.createTransaction();
+        return new CommonDaoTransaction(tx);
     }
     logResult(started, op, res, table) {
         if (!this.cfg.logLevel)
@@ -1111,3 +1062,65 @@ class CommonDao {
     }
 }
 exports.CommonDao = CommonDao;
+class CommonDaoTransaction {
+    constructor(tx) {
+        this.tx = tx;
+    }
+    async commit() {
+        await this.tx.commit();
+    }
+    async rollback() {
+        try {
+            await this.tx.rollback();
+        }
+        catch (err) {
+            console.log(err);
+        }
+    }
+    async getById(dao, id, opt) {
+        return (await this.getByIds(dao, [id], opt))[0] || null;
+    }
+    async getByIds(dao, ids, opt) {
+        try {
+            return await dao.getByIds(ids, { ...opt, tx: this.tx });
+        }
+        catch (err) {
+            await this.rollback();
+            throw err;
+        }
+    }
+    async runQuery(dao, q, opt) {
+        try {
+            return await dao.runQuery(q, { ...opt, tx: this.tx });
+        }
+        catch (err) {
+            await this.rollback();
+            throw err;
+        }
+    }
+    async save(dao, bm, opt) {
+        return (await this.saveBatch(dao, [bm], opt))[0];
+    }
+    async saveBatch(dao, bms, opt) {
+        try {
+            return await dao.saveBatch(bms, { ...opt, tx: this.tx });
+        }
+        catch (err) {
+            await this.rollback();
+            throw err;
+        }
+    }
+    async deleteById(dao, id, opt) {
+        return await this.deleteByIds(dao, [id], opt);
+    }
+    async deleteByIds(dao, ids, opt) {
+        try {
+            return await dao.deleteByIds(ids, { ...opt, tx: this.tx });
+        }
+        catch (err) {
+            await this.rollback();
+            throw err;
+        }
+    }
+}
+exports.CommonDaoTransaction = CommonDaoTransaction;

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

@@ -222,16 +222,6 @@ export interface CommonDaoOptions extends CommonDBOptions {
      * Useful e.g in AirtableDB where you can have one Dao to control multiple tables.
      */
     table?: string;
-    /**
-     * 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;
 }
 export interface CommonDaoSaveOptions<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId> extends CommonDaoSaveBatchOptions<DBM> {
     /**

package/dist/db.model.d.ts

@@ -1,4 +1,4 @@
-import { ObjectWithId } from '@naturalcycles/js-lib';
+import type { ObjectWithId } from '@naturalcycles/js-lib';
 /**
  * Similar to SQL INSERT, UPDATE.
  * Insert will fail if row already exists.
@@ -8,7 +8,18 @@ import { ObjectWithId } from '@naturalcycles/js-lib';
  * Default is Upsert.
  */
 export type CommonDBSaveMethod = 'upsert' | 'insert' | 'update';
+export interface DBTransaction {
+    commit: () => Promise<void>;
+    rollback: () => Promise<void>;
+}
 export interface CommonDBOptions {
+    /**
+     * If passed - the operation will be performed in the context of that DBTransaction.
+     * Note that not every type of operation supports Transaction
+     * (e.g in Datastore queries cannot be executed inside a Transaction).
+     * Also, not every CommonDB implementation supports Transactions.
+     */
+    tx?: DBTransaction;
 }
 /**
  * All properties default to undefined.

package/dist/index.d.ts

@@ -13,6 +13,5 @@ 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';

package/dist/index.js

@@ -16,6 +16,5 @@ 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/pipeline/dbPipelineBackup.js

@@ -23,7 +23,7 @@ async function dbPipelineBackup(opt) {
     const gzip = opt.gzip !== false; // default to true
     let { tables } = opt;
     console.log(`>> ${(0, nodejs_lib_1.dimWhite)('dbPipelineBackup')} started in ${(0, nodejs_lib_1.grey)(outputDirPath)}...`);
-    (0, nodejs_lib_1._ensureDirSync)(outputDirPath);
+    nodejs_lib_1.fs2.ensureDir(outputDirPath);
     tables ||= await db.getTables();
     console.log(`${(0, nodejs_lib_1.yellow)(tables.length)} ${(0, nodejs_lib_1.boldWhite)('table(s)')}:\n` + tables.join('\n'));
     const statsPerTable = {};
@@ -46,16 +46,16 @@ async function dbPipelineBackup(opt) {
         }
         const filePath = `${outputDirPath}/${table}.ndjson` + (gzip ? '.gz' : '');
         const schemaFilePath = `${outputDirPath}/${table}.schema.json`;
-        if (protectFromOverwrite && (0, nodejs_lib_1._pathExistsSync)(filePath)) {
+        if (protectFromOverwrite && nodejs_lib_1.fs2.pathExists(filePath)) {
             throw new js_lib_1.AppError(`dbPipelineBackup: output file exists: ${filePath}`);
         }
         const started = Date.now();
         let rows = 0;
-        (0, nodejs_lib_1._ensureFileSync)(filePath);
+        nodejs_lib_1.fs2.ensureFile(filePath);
         // console.log(`>> ${grey(filePath)} started...`)
         if (emitSchemaFromDB) {
             const schema = await db.getTableSchema(table);
-            await (0, nodejs_lib_1._writeJson)(schemaFilePath, schema, { spaces: 2 });
+            await nodejs_lib_1.fs2.writeJsonAsync(schemaFilePath, schema, { spaces: 2 });
             console.log(`>> ${(0, nodejs_lib_1.grey)(schemaFilePath)} saved (generated from DB)`);
         }
         await (0, nodejs_lib_1._pipeline)([

package/dist/pipeline/dbPipelineRestore.js

@@ -19,7 +19,7 @@ async function dbPipelineRestore(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}`);
-    (0, nodejs_lib_1._ensureDirSync)(inputDirPath);
+    nodejs_lib_1.fs2.ensureDir(inputDirPath);
     const tablesToGzip = new Set();
     const sizeByTable = {};
     const statsPerTable = {};
@@ -54,7 +54,7 @@ async function dbPipelineRestore(opt) {
                 console.warn(`${schemaFilePath} does not exist!`);
                 return;
             }
-            const schema = await (0, nodejs_lib_1._readJson)(schemaFilePath);
+            const schema = await nodejs_lib_1.fs2.readJsonAsync(schemaFilePath);
             await db.createTable(table, schema, { dropIfExists: true });
         });
     }

package/dist/testing/daoTest.d.ts

@@ -1,3 +1,3 @@
 import { CommonDB } from '../common.db';
-import { CommonDBImplementationFeatures, CommonDBImplementationQuirks } from './dbTest';
-export declare function runCommonDaoTest(db: CommonDB, features?: CommonDBImplementationFeatures, quirks?: CommonDBImplementationQuirks): void;
+import { CommonDBImplementationQuirks } from './dbTest';
+export declare function runCommonDaoTest(db: CommonDB, quirks?: CommonDBImplementationQuirks): void;

package/dist/testing/daoTest.js

@@ -8,7 +8,8 @@ const __1 = require("..");
 const common_dao_1 = require("../commondao/common.dao");
 const dbTest_1 = require("./dbTest");
 const test_model_1 = require("./test.model");
-function runCommonDaoTest(db, features = {}, quirks = {}) {
+function runCommonDaoTest(db, quirks = {}) {
+    const { support } = db;
     const dao = new common_dao_1.CommonDao({
         table: test_model_1.TEST_TABLE,
         db,
@@ -18,16 +19,6 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         logStarted: true,
         logLevel: __1.CommonDaoLogLevel.DATA_FULL,
     });
-    const { querying = true, 
-    // tableSchemas = true,
-    createTable = true, dbQueryFilter = true, 
-    // dbQueryFilterIn = true,
-    dbQueryOrder = true, dbQuerySelectFields = true, streaming = true, strongConsistency = true, nullValues = true, transactions = true, } = features;
-    // const {
-    // allowExtraPropertiesInResponse,
-    // allowBooleansAsUndefined,
-    // } = quirks
-    const eventualConsistencyDelay = !strongConsistency && quirks.eventualConsistencyDelay;
     const items = (0, test_model_1.createTestItemsBM)(3);
     const itemsClone = (0, js_lib_1._deepCopy)(items);
     // deepFreeze(items) // mutation of id/created/updated is allowed now! (even expected)
@@ -40,12 +31,12 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         await dao.ping();
     });
     // CREATE TABLE, DROP
-    if (createTable) {
+    if (support.createTable) {
         test('createTable, dropIfExists=true', async () => {
             await dao.createTable(test_model_1.testItemDBMJsonSchema, { dropIfExists: true });
         });
     }
-    if (querying) {
+    if (support.queries) {
         // DELETE ALL initially
         test('deleteByIds test items', async () => {
             const rows = await dao.query().select(['id']).runQuery();
@@ -53,8 +44,6 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         });
         // QUERY empty
         test('runQuery(all), runQueryCount should return empty', async () => {
-            if (eventualConsistencyDelay)
-                await (0, js_lib_1.pDelay)(eventualConsistencyDelay);
             expect(await dao.query().runQuery()).toEqual([]);
             expect(await dao.query().runQueryCount()).toBe(0);
         });
@@ -72,7 +61,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         expect(await dao.getByIds(['abc', 'abcd'])).toEqual([]);
     });
     // SAVE
-    if (nullValues) {
+    if (support.nullValues) {
         test('should allow to save and load null values', async () => {
             const item3 = {
                 ...(0, test_model_1.createTestItemBM)(3),
@@ -118,28 +107,26 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         (0, dbTest_1.expectMatch)(expectedItems, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
     });
     // QUERY
-    if (querying) {
+    if (support.queries) {
         test('runQuery(all) should return all items', async () => {
-            if (eventualConsistencyDelay)
-                await (0, js_lib_1.pDelay)(eventualConsistencyDelay);
             let rows = await dao.query().runQuery();
             rows = (0, js_lib_1._sortBy)(rows, r => r.id);
             (0, dbTest_1.expectMatch)(expectedItems, rows, quirks);
         });
-        if (dbQueryFilter) {
+        if (support.dbQueryFilter) {
             test('query even=true', async () => {
                 let rows = await dao.query().filter('even', '==', true).runQuery();
                 rows = (0, js_lib_1._sortBy)(rows, r => r.id);
                 (0, dbTest_1.expectMatch)(expectedItems.filter(i => i.even), rows, quirks);
             });
         }
-        if (dbQueryOrder) {
+        if (support.dbQueryOrder) {
             test('query order by k1 desc', async () => {
                 const rows = await dao.query().order('k1', true).runQuery();
                 (0, dbTest_1.expectMatch)([...expectedItems].reverse(), rows, quirks);
             });
         }
-        if (dbQuerySelectFields) {
+        if (support.dbQuerySelectFields) {
             test('projection query with only ids', async () => {
                 let rows = await dao.query().select(['id']).runQuery();
                 rows = (0, js_lib_1._sortBy)(rows, r => r.id);
@@ -151,7 +138,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         });
     }
     // STREAM
-    if (streaming) {
+    if (support.streaming) {
         test('streamQueryForEach all', async () => {
             let rows = [];
             await dao.query().streamQueryForEach(bm => void rows.push(bm));
@@ -187,12 +174,10 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         });
     }
     // DELETE BY
-    if (querying) {
+    if (support.queries) {
         test('deleteByQuery even=false', async () => {
             const deleted = await dao.query().filter('even', '==', false).deleteByQuery();
             expect(deleted).toBe(items.filter(item => !item.even).length);
-            if (eventualConsistencyDelay)
-                await (0, js_lib_1.pDelay)(eventualConsistencyDelay);
             expect(await dao.query().runQueryCount()).toBe(1);
         });
         test('cleanup', async () => {
@@ -200,42 +185,47 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
             await dao.query().deleteByQuery();
         });
     }
-    if (transactions) {
+    if (support.transactions) {
         test('transaction happy path', async () => {
             // cleanup
             await dao.query().deleteByQuery();
             // Test that id, created, updated are created
             const now = (0, js_lib_1.localTimeNow)().unix();
-            await dao.runInTransaction([dao.tx.save((0, js_lib_1._omit)(item1, ['id', 'created', 'updated']))]);
+            await dao.useTransaction(async (tx) => {
+                const row = (0, js_lib_1._omit)(item1, ['id', 'created', 'updated']);
+                await tx.save(dao, row);
+            });
             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)]);
+            await dao.useTransaction(async (tx) => {
+                await tx.deleteById(dao, 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),
-            ]);
+            await dao.useTransaction(async (tx) => {
+                await tx.saveBatch(dao, items);
+                await tx.save(dao, { ...items[2], k1: 'k1_mod' });
+                await tx.deleteById(dao, 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();
+            await expect(dao.useTransaction(async (tx) => {
+                await tx.deleteById(dao, items[2].id);
+                await tx.save(dao, { ...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) {
+        if (support.queries) {
             test('transaction cleanup', async () => {
                 await dao.query().deleteByQuery();
             });