@naturalcycles/db-lib 8.60.1 → 9.1.0

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, CommonLogger, 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,34 @@ 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>;
+    runInTransaction(fn: CommonDaoTransactionFn): Promise<void>;
     protected logResult(started: number, op: string, res: any, table: string): void;
     protected logSaveResult(started: number, op: string, table: string): void;
     protected logStarted(op: string, table: string, force?: boolean): UnixTimestampMillisNumber;
     protected logSaveStarted(op: string, items: any, table: string): UnixTimestampMillisNumber;
 }
+/**
+ * Transaction is committed when the function returns resolved Promise (aka "returns normally").
+ *
+ * Transaction is rolled back when the function returns rejected Promise (aka "throws").
+ */
+export type CommonDaoTransactionFn = (tx: CommonDaoTransaction) => Promise<void>;
+/**
+ * Transaction context.
+ * Has similar API than CommonDao, but all operations are performed in the context of the transaction.
+ */
+export declare class CommonDaoTransaction {
+    private tx;
+    private logger;
+    constructor(tx: DBTransaction, logger: CommonLogger);
+    /**
+     * Perform a graceful rollback without throwing/re-throwing any error.
+     */
+    rollback(): Promise<void>;
+    getById<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, id: string, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
+    getByIds<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, ids: string[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    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
@@ -176,7 +124,7 @@ class CommonDao {
         const op = `getByIds ${ids.length} id(s) (${(0, js_lib_1._truncate)(ids.slice(0, 10).join(', '), 50)})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        let dbms = await this.cfg.db.getByIds(table, ids);
+        let dbms = await (opt.tx || this.cfg.db).getByIds(table, ids);
         if (!opt.raw && this.cfg.hooks.afterLoad && dbms.length) {
             dbms = (await (0, js_lib_1.pMap)(dbms, async (dbm) => await this.cfg.hooks.afterLoad(dbm))).filter(js_lib_1._isTruthy);
         }
@@ -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) {
@@ -721,7 +662,7 @@ class CommonDao {
         const started = this.logSaveStarted(op, bms, table);
         const { excludeFromIndexes } = this.cfg;
         const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds;
-        await this.cfg.db.saveBatch(table, dbms, {
+        await (opt.tx || this.cfg.db).saveBatch(table, dbms, {
             excludeFromIndexes,
             assignGeneratedIds,
             ...opt,
@@ -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 (opt.tx || this.cfg.db).deleteByIds(table, ids, opt);
         this.logSaveResult(started, op, table);
         return count;
     }
@@ -1050,11 +991,17 @@ 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 runInTransaction(fn) {
+        await this.cfg.db.runInTransaction(async (tx) => {
+            const daoTx = new CommonDaoTransaction(tx, this.cfg.logger);
+            try {
+                await fn(daoTx);
+            }
+            catch (err) {
+                await daoTx.rollback();
+                throw err;
+            }
+        });
     }
     logResult(started, op, res, table) {
         if (!this.cfg.logLevel)
@@ -1111,3 +1058,57 @@ class CommonDao {
     }
 }
 exports.CommonDao = CommonDao;
+/**
+ * Transaction context.
+ * Has similar API than CommonDao, but all operations are performed in the context of the transaction.
+ */
+class CommonDaoTransaction {
+    constructor(tx, logger) {
+        this.tx = tx;
+        this.logger = logger;
+    }
+    /**
+     * Perform a graceful rollback without throwing/re-throwing any error.
+     */
+    async rollback() {
+        try {
+            await this.tx.rollback();
+        }
+        catch (err) {
+            // graceful rollback without re-throw
+            this.logger.error(err);
+        }
+    }
+    async getById(dao, id, opt) {
+        return (await this.getByIds(dao, [id], opt))[0] || null;
+    }
+    async getByIds(dao, ids, opt) {
+        return await dao.getByIds(ids, { ...opt, tx: this.tx });
+    }
+    // todo: Queries inside Transaction are not supported yet
+    // async runQuery<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(
+    //   dao: CommonDao<BM, DBM, any>,
+    //   q: DBQuery<DBM>,
+    //   opt?: CommonDaoOptions,
+    // ): Promise<Saved<BM>[]> {
+    //   try {
+    //     return await dao.runQuery(q, { ...opt, tx: this.tx })
+    //   } catch (err) {
+    //     await this.rollback()
+    //     throw err
+    //   }
+    // }
+    async save(dao, bm, opt) {
+        return (await this.saveBatch(dao, [bm], opt))[0];
+    }
+    async saveBatch(dao, bms, opt) {
+        return await dao.saveBatch(bms, { ...opt, tx: this.tx });
+    }
+    async deleteById(dao, id, opt) {
+        return await this.deleteByIds(dao, [id], opt);
+    }
+    async deleteByIds(dao, ids, opt) {
+        return await dao.deleteByIds(ids, { ...opt, tx: this.tx });
+    }
+}
+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,5 @@
-import { ObjectWithId } from '@naturalcycles/js-lib';
+import type { ObjectWithId } from '@naturalcycles/js-lib';
+import { CommonDB } from './common.db';
 /**
  * Similar to SQL INSERT, UPDATE.
  * Insert will fail if row already exists.
@@ -8,7 +9,34 @@ import { ObjectWithId } from '@naturalcycles/js-lib';
  * Default is Upsert.
  */
 export type CommonDBSaveMethod = 'upsert' | 'insert' | 'update';
+/**
+ * Transaction is committed when the function returns resolved Promise (aka "returns normally").
+ *
+ * Transaction is rolled back when the function returns rejected Promise (aka "throws").
+ */
+export type DBTransactionFn = (tx: DBTransaction) => Promise<void>;
+/**
+ * Transaction context.
+ * Has similar API than CommonDB, but all operations are performed in the context of the transaction.
+ */
+export interface DBTransaction {
+    getByIds: CommonDB['getByIds'];
+    saveBatch: CommonDB['saveBatch'];
+    deleteByIds: CommonDB['deleteByIds'];
+    /**
+     * Perform a graceful rollback.
+     * It'll rollback the transaction and won't throw/re-throw any errors.
+     */
+    rollback: () => Promise<void>;
+}
 export interface CommonDBOptions {
+    /**
+     * 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/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.runInTransaction(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.runInTransaction(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.runInTransaction(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.runInTransaction(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();
             });

package/dist/testing/dbTest.d.ts

@@ -1,43 +1,8 @@
 import { CommonDB } from '../common.db';
-export interface CommonDBImplementationFeatures {
-    /**
-     * All querying functionality.
-     */
-    querying?: boolean;
-    dbQueryFilter?: boolean;
-    dbQueryFilterIn?: boolean;
-    dbQueryOrder?: boolean;
-    dbQuerySelectFields?: boolean;
-    insert?: boolean;
-    update?: boolean;
-    updateByQuery?: boolean;
-    dbIncrement?: boolean;
-    createTable?: boolean;
-    tableSchemas?: boolean;
-    /**
-     * Queries should return fresh results immediately.
-     * Datastore is the one known to NOT have strong consistency for queries (not for getById though).
-     */
-    strongConsistency?: boolean;
-    streaming?: boolean;
-    bufferSupport?: boolean;
-    nullValues?: boolean;
-    /**
-     * Set false for SQL (relational) databases,
-     * they will return `null` for all missing properties.
-     */
-    documentDB?: boolean;
-    transactions?: boolean;
-}
 /**
  * All options default to `false`.
  */
 export interface CommonDBImplementationQuirks {
-    /**
-     * Applicable to e.g Datastore.
-     * Time in milliseconds to wait for eventual consistency to propagate.
-     */
-    eventualConsistencyDelay?: number;
     /**
      * Example: airtableId
      */
@@ -47,8 +12,5 @@ export interface CommonDBImplementationQuirks {
      */
     allowBooleansAsUndefined?: boolean;
 }
-/**
- * All unclaimed features will default to 'true'
- */
-export declare function runCommonDBTest(db: CommonDB, features?: CommonDBImplementationFeatures, quirks?: CommonDBImplementationQuirks): void;
+export declare function runCommonDBTest(db: CommonDB, quirks?: CommonDBImplementationQuirks): void;
 export declare function expectMatch(expected: any[], actual: any[], quirks: CommonDBImplementationQuirks): void;