@naturalcycles/db-lib 8.60.0 → 9.0.0

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;

package/dist/testing/dbTest.js

@@ -3,23 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectMatch = exports.runCommonDBTest = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
+const common_db_1 = require("../common.db");
 const db_model_1 = require("../db.model");
 const dbQuery_1 = require("../query/dbQuery");
-const dbTransaction_1 = require("../transaction/dbTransaction");
 const test_model_1 = require("./test.model");
 const test_util_1 = require("./test.util");
-/**
- * All unclaimed features will default to 'true'
- */
-function runCommonDBTest(db, features = {}, quirks = {}) {
-    const { querying = true, tableSchemas = true, createTable = true, dbQueryFilter = true, 
-    // dbQueryFilterIn = true,
-    dbQueryOrder = true, dbQuerySelectFields = true, insert = true, update = true, updateByQuery = true, dbIncrement = true, streaming = true, strongConsistency = true, bufferSupport = true, nullValues = true, documentDB = true, transactions = true, } = features;
-    // const {
-    // allowExtraPropertiesInResponse,
-    // allowBooleansAsUndefined,
-    // } = quirks
-    const eventualConsistencyDelay = !strongConsistency && quirks.eventualConsistencyDelay;
+function runCommonDBTest(db, quirks = {}) {
+    const { support } = db;
     const items = (0, test_model_1.createTestItemsDBM)(3);
     (0, test_util_1.deepFreeze)(items);
     const item1 = items[0];
@@ -28,12 +18,12 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
         await db.ping();
     });
     // CREATE TABLE, DROP
-    if (createTable) {
+    if (support.createTable) {
         test('createTable, dropIfExists=true', async () => {
             await db.createTable(test_model_1.TEST_TABLE, test_model_1.testItemDBMJsonSchema, { dropIfExists: true });
         });
     }
-    if (querying) {
+    if (support.queries) {
         // DELETE ALL initially
         test('deleteByIds test items', async () => {
             const { rows } = await db.runQuery(queryAll().select(['id']));
@@ -41,8 +31,6 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
         });
         // QUERY empty
         test('runQuery(all), runQueryCount should return empty', async () => {
-            if (eventualConsistencyDelay)
-                await (0, js_lib_1.pDelay)(eventualConsistencyDelay);
             expect((await db.runQuery(queryAll())).rows).toEqual([]);
             expect(await db.runQueryCount(queryAll())).toBe(0);
         });
@@ -60,7 +48,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
         expect(await db.getByIds(test_model_1.TEST_TABLE, ['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.createTestItemDBM)(3),
@@ -73,7 +61,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             expect(item3Loaded.k2).toBeNull();
         });
     }
-    if (documentDB) {
+    if (db.dbType === common_db_1.CommonDBType.document) {
         test('undefined values should not be saved/loaded', async () => {
             const item3 = {
                 ...(0, test_model_1.createTestItemDBM)(3),
@@ -89,7 +77,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             expect(Object.keys(item3Loaded)).not.toContain('k2');
         });
     }
-    if (update) {
+    if (support.updateSaveMethod) {
         test('saveBatch UPDATE method should throw', async () => {
             await expect(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'update' })).rejects.toThrow();
         });
@@ -100,12 +88,12 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
     test('saveBatch should throw on null id', async () => {
         await expect(db.saveBatch(test_model_1.TEST_TABLE, [{ ...item1, id: null }])).rejects.toThrow();
     });
-    if (insert) {
+    if (support.insertSaveMethod) {
         test('saveBatch INSERT method should throw', async () => {
             await expect(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'insert' })).rejects.toThrow();
         });
     }
-    if (update) {
+    if (support.updateSaveMethod) {
         test('saveBatch UPDATE method should pass', async () => {
             await db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'update' });
         });
@@ -116,31 +104,29 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
         expectMatch(items, (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 db.runQuery(queryAll());
             rows = (0, js_lib_1._sortBy)(rows, r => r.id); // because query doesn't specify order here
             expectMatch(items, rows, quirks);
         });
-        if (dbQueryFilter) {
+        if (support.dbQueryFilter) {
             test('query even=true', async () => {
                 const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).filter('even', '==', true);
                 let { rows } = await db.runQuery(q);
-                if (!dbQueryOrder)
+                if (!support.dbQueryOrder)
                     rows = (0, js_lib_1._sortBy)(rows, r => r.id);
                 expectMatch(items.filter(i => i.even), rows, quirks);
             });
         }
-        if (dbQueryOrder) {
+        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 { rows } = await db.runQuery(q);
                 expectMatch([...items].reverse(), rows, quirks);
             });
         }
-        if (dbQuerySelectFields) {
+        if (support.dbQuerySelectFields) {
             test('projection query with only ids', async () => {
                 const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).select(['id']);
                 let { rows } = await db.runQuery(q);
@@ -164,7 +150,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
         });
     }
     // STREAM
-    if (streaming) {
+    if (support.streaming) {
         test('streamQuery all', async () => {
             let rows = await (0, nodejs_lib_1.readableToArray)(db.streamQuery(queryAll()));
             rows = (0, js_lib_1._sortBy)(rows, r => r.id); // cause order is not specified in DBQuery
@@ -175,7 +161,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
     test('getTables, getTableSchema (if supported)', async () => {
         const tables = await db.getTables();
         // console.log({ tables })
-        if (tableSchemas) {
+        if (support.tableSchemas) {
             await (0, js_lib_1.pMap)(tables, async (table) => {
                 const schema = await db.getTableSchema(table);
                 // console.log(schema)
@@ -184,19 +170,17 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
         }
     });
     // DELETE BY
-    if (querying && dbQueryFilter) {
+    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 deleted = await db.deleteByQuery(q);
             expect(deleted).toBe(items.filter(item => !item.even).length);
-            if (eventualConsistencyDelay)
-                await (0, js_lib_1.pDelay)(eventualConsistencyDelay);
             expect(await db.runQueryCount(queryAll())).toBe(1);
         });
     }
     // BUFFER
-    if (bufferSupport) {
-        test('buffer support', async () => {
+    if (support.bufferValues) {
+        test('buffer values', async () => {
             const s = 'helloWorld 1';
             const b1 = Buffer.from(s);
             const item = {
@@ -218,7 +202,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             expect(b1Loaded.toString()).toBe(s);
         });
     }
-    if (transactions) {
+    if (support.transactions) {
         test('transaction happy path', async () => {
             // cleanup
             await db.deleteByQuery(queryAll());
@@ -226,27 +210,34 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             // save item3 with k1: k1_mod
             // delete item2
             // remaining: item1, item3_with_k1_mod
-            const tx = dbTransaction_1.DBTransaction.create()
-                .saveBatch(test_model_1.TEST_TABLE, items)
-                .save(test_model_1.TEST_TABLE, { ...items[2], k1: 'k1_mod' })
-                .deleteById(test_model_1.TEST_TABLE, items[1].id);
-            await db.commitTransaction(tx);
+            const tx = await db.createTransaction();
+            await db.saveBatch(test_model_1.TEST_TABLE, items, { tx });
+            await db.saveBatch(test_model_1.TEST_TABLE, [{ ...items[2], k1: 'k1_mod' }], { tx });
+            await db.deleteByIds(test_model_1.TEST_TABLE, [items[1].id], { tx });
+            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 () => {
             // It should fail on id == null
-            const tx = dbTransaction_1.DBTransaction.create()
-                .deleteById(test_model_1.TEST_TABLE, items[2].id)
-                .save(test_model_1.TEST_TABLE, { ...items[0], k1: 5, id: null });
-            await expect(db.commitTransaction(tx)).rejects.toThrow();
+            let err;
+            try {
+                const tx = await db.createTransaction();
+                await db.deleteByIds(test_model_1.TEST_TABLE, [items[2].id], { tx });
+                await db.saveBatch(test_model_1.TEST_TABLE, [{ ...items[0], k1: 5, id: null }], { tx });
+                await tx.commit();
+            }
+            catch (err_) {
+                err = err_;
+            }
+            expect(err).toBeDefined();
             const { rows } = await db.runQuery(queryAll());
             const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
             expectMatch(expected, rows, quirks);
         });
     }
-    if (updateByQuery) {
+    if (support.updateByQuery) {
         test('updateByQuery simple', async () => {
             // cleanup, reset initial data
             await db.deleteByQuery(queryAll());
@@ -265,7 +256,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             });
             expectMatch(expected, rows, quirks);
         });
-        if (dbIncrement) {
+        if (support.dbIncrement) {
             test('updateByQuery DBIncrement', async () => {
                 // cleanup, reset initial data
                 await db.deleteByQuery(queryAll());
@@ -286,7 +277,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             });
         }
     }
-    if (querying) {
+    if (support.queries) {
         test('cleanup', async () => {
             // CLEAN UP
             await db.deleteByQuery(queryAll());

package/dist/testing/index.d.ts

@@ -1,6 +1,6 @@
 import { runCommonDaoTest } from './daoTest';
-import { CommonDBImplementationFeatures, CommonDBImplementationQuirks, runCommonDBTest } from './dbTest';
+import { CommonDBImplementationQuirks, runCommonDBTest } from './dbTest';
 import { runCommonKeyValueDBTest } from './keyValueDBTest';
 import { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, TestItemBM, testItemBMJsonSchema, testItemBMSchema, TestItemDBM, testItemDBMJsonSchema, testItemDBMSchema, TestItemTM, testItemTMSchema, TEST_TABLE } from './test.model';
-export type { TestItemDBM, TestItemBM, TestItemTM, CommonDBImplementationFeatures, CommonDBImplementationQuirks, };
+export type { TestItemDBM, TestItemBM, TestItemTM, CommonDBImplementationQuirks };
 export { TEST_TABLE, createTestItemDBM, createTestItemBM, createTestItemsDBM, createTestItemsBM, testItemDBMSchema, testItemBMSchema, testItemTMSchema, testItemBMJsonSchema, testItemDBMJsonSchema, runCommonDBTest, runCommonDaoTest, runCommonKeyValueDBTest, };

package/dist/timeseries/commonTimeSeriesDao.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonTimeSeriesDao = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
-const __1 = require("..");
 const dbQuery_1 = require("../query/dbQuery");
 const _TIMESERIES_RAW = '_TIMESERIES_RAW';
 /**
@@ -43,16 +42,16 @@ class CommonTimeSeriesDao {
     async commitTransaction(ops) {
         if (!ops.length)
             return;
-        const tx = __1.DBTransaction.create();
-        ops.forEach(op => {
+        const tx = await this.cfg.db.createTransaction();
+        for (const op of ops) {
             const rows = op.dataPoints.map(([ts, v]) => ({
                 id: String(ts), // Convert Number id into String id, as per CommonDB
                 ts, // to allow querying by ts, since querying by id is not always available (Datastore is one example)
                 v,
             }));
-            tx.saveBatch(`${op.series}${_TIMESERIES_RAW}`, rows);
-        });
-        await this.cfg.db.commitTransaction(tx);
+            await this.cfg.db.saveBatch(`${op.series}${_TIMESERIES_RAW}`, rows, { tx });
+        }
+        await tx.commit();
     }
     async deleteById(series, tsMillis) {
         await this.deleteByIds(series, [tsMillis]);

package/dist/transaction/dbTransaction.util.d.ts

@@ -1,6 +1,7 @@
+import { ObjectWithId } from '@naturalcycles/js-lib';
 import type { CommonDB } from '../common.db';
-import { CommonDBSaveOptions, DBOperation } from '../db.model';
-import { DBTransaction } from './dbTransaction';
+import { CommonDBOptions, CommonDBSaveOptions, DBTransaction, RunQueryResult } from '../db.model';
+import { DBQuery } from '../query/dbQuery';
 /**
  * Optimizes the Transaction (list of DBOperations) to do less operations.
  * E.g if you save id1 first and then delete it - this function will turn it into a no-op (self-eliminate).
@@ -9,10 +10,22 @@ import { DBTransaction } from './dbTransaction';
  * Currently only takes into account SaveBatch and DeleteByIds ops.
  * Output ops are maximum 1 per entity - save or delete.
  */
-export declare function mergeDBOperations(ops: DBOperation[]): DBOperation[];
 /**
  * Naive implementation of "Transaction" which just executes all operations one-by-one.
  * Does NOT actually implement a Transaction, cause partial ops application will happen
  * in case of an error in the middle.
  */
-export declare function commitDBTransactionSimple(db: CommonDB, tx: DBTransaction, opt?: CommonDBSaveOptions): Promise<void>;
+/**
+ * Fake implementation of DBTransactionContext,
+ * which executes all operations instantly, without any Transaction involved.
+ */
+export declare class FakeDBTransaction implements DBTransaction {
+    protected db: CommonDB;
+    constructor(db: CommonDB);
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
+    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
+    saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    deleteByIds(table: string, ids: string[], opt?: CommonDBOptions | undefined): Promise<number>;
+}

package/dist/transaction/dbTransaction.util.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.commitDBTransactionSimple = exports.mergeDBOperations = void 0;
-const dbQuery_1 = require("../query/dbQuery");
+exports.FakeDBTransaction = void 0;
 /**
  * Optimizes the Transaction (list of DBOperations) to do less operations.
  * E.g if you save id1 first and then delete it - this function will turn it into a no-op (self-eliminate).
@@ -10,10 +9,9 @@ const dbQuery_1 = require("../query/dbQuery");
  * Currently only takes into account SaveBatch and DeleteByIds ops.
  * Output ops are maximum 1 per entity - save or delete.
  */
-function mergeDBOperations(ops) {
-    return ops; // currently "does nothing"
-}
-exports.mergeDBOperations = mergeDBOperations;
+// export function mergeDBOperations(ops: DBOperation[]): DBOperation[] {
+//   return ops // currently "does nothing"
+// }
 // Commented out as "overly complicated"
 /*
 export function mergeDBOperations(ops: DBOperation[]): DBOperation[] {
@@ -68,21 +66,47 @@ export function mergeDBOperations(ops: DBOperation[]): DBOperation[] {
  * Does NOT actually implement a Transaction, cause partial ops application will happen
  * in case of an error in the middle.
  */
-async function commitDBTransactionSimple(db, tx, opt) {
-    // const ops = mergeDBOperations(tx.ops)
-    for await (const op of tx.ops) {
-        if (op.type === 'saveBatch') {
-            await db.saveBatch(op.table, op.rows, { ...op.opt, ...opt });
-        }
-        else if (op.type === 'deleteByIds') {
-            await db.deleteByQuery(dbQuery_1.DBQuery.create(op.table).filter('id', 'in', op.ids), {
-                ...op.opt,
-                ...opt,
-            });
-        }
-        else {
-            throw new Error(`DBOperation not supported: ${op.type}`);
-        }
+// export async function commitDBTransactionSimple(
+//   db: CommonDB,
+//   ops: DBOperation[],
+//   opt?: CommonDBSaveOptions,
+// ): Promise<void> {
+//   // const ops = mergeDBOperations(tx.ops)
+//
+//   for await (const op of ops) {
+//     if (op.type === 'saveBatch') {
+//       await db.saveBatch(op.table, op.rows, { ...op.opt, ...opt })
+//     } else if (op.type === 'deleteByIds') {
+//       await db.deleteByQuery(DBQuery.create(op.table).filter('id', 'in', op.ids), {
+//         ...op.opt,
+//         ...opt,
+//       })
+//     } else {
+//       throw new Error(`DBOperation not supported: ${(op as any).type}`)
+//     }
+//   }
+// }
+/**
+ * Fake implementation of DBTransactionContext,
+ * which executes all operations instantly, without any Transaction involved.
+ */
+class FakeDBTransaction {
+    constructor(db) {
+        this.db = db;
+    }
+    async commit() { }
+    async rollback() { }
+    async getByIds(table, ids, opt) {
+        return await this.db.getByIds(table, ids, opt);
+    }
+    async runQuery(q, opt) {
+        return await this.db.runQuery(q, opt);
+    }
+    async saveBatch(table, rows, opt) {
+        return await this.db.saveBatch(table, rows, opt);
+    }
+    async deleteByIds(table, ids, opt) {
+        return await this.db.deleteByIds(table, ids, opt);
     }
 }
-exports.commitDBTransactionSimple = commitDBTransactionSimple;
+exports.FakeDBTransaction = FakeDBTransaction;

package/dist/validation/index.js

@@ -4,8 +4,8 @@ exports.dbQuerySchema = exports.dbQueryOrderSchema = exports.dbQueryFilterSchema
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const dbQuery_1 = require("../query/dbQuery");
 exports.commonDBOptionsSchema = (0, nodejs_lib_1.objectSchema)({
-    onlyCache: nodejs_lib_1.booleanSchema.optional(),
-    skipCache: nodejs_lib_1.booleanSchema.optional(),
+    ['onlyCache']: nodejs_lib_1.booleanSchema.optional(),
+    ['skipCache']: nodejs_lib_1.booleanSchema.optional(),
 });
 exports.commonDBSaveOptionsSchema = (0, nodejs_lib_1.objectSchema)({
     excludeFromIndexes: (0, nodejs_lib_1.arraySchema)(nodejs_lib_1.stringSchema).optional(),

package/package.json

@@ -40,7 +40,7 @@
   "engines": {
     "node": ">=18.12"
   },
-  "version": "8.60.0",
+  "version": "9.0.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/adapter/cachedb/cache.db.model.ts

@@ -1,6 +1,11 @@
 import { CommonLogger, ObjectWithId } from '@naturalcycles/js-lib'
 import { CommonDB } from '../../common.db'
-import { CommonDBCreateOptions, CommonDBSaveOptions, CommonDBStreamOptions } from '../../db.model'
+import {
+  CommonDBCreateOptions,
+  CommonDBOptions,
+  CommonDBSaveOptions,
+  CommonDBStreamOptions,
+} from '../../db.model'
 
 export interface CacheDBCfg {
   name: string
@@ -45,7 +50,7 @@ export interface CacheDBCfg {
   logger?: CommonLogger
 }
 
-export interface CacheDBOptions {
+export interface CacheDBOptions extends CommonDBOptions {
   /**
    * @default false
    */

package/src/adapter/cachedb/cache.db.ts

@@ -7,10 +7,9 @@ import {
   StringMap,
 } from '@naturalcycles/js-lib'
 import { BaseCommonDB } from '../../base.common.db'
-import { CommonDB } from '../../common.db'
-import { CommonDBOptions, DBPatch, RunQueryResult } from '../../db.model'
+import { CommonDB, commonDBFullSupport, CommonDBSupport } from '../../common.db'
+import { DBPatch, RunQueryResult } from '../../db.model'
 import { DBQuery } from '../../query/dbQuery'
-import { DBTransaction } from '../../transaction/dbTransaction'
 import {
   CacheDBCfg,
   CacheDBCreateOptions,
@@ -26,6 +25,11 @@ import {
  * Queries always hit downstream (unless `onlyCache` is passed)
  */
 export class CacheDB extends BaseCommonDB implements CommonDB {
+  override support: CommonDBSupport = {
+    ...commonDBFullSupport,
+    transactions: false,
+  }
+
   constructor(cfg: CacheDBCfg) {
     super()
     this.cfg = {
@@ -284,9 +288,4 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
 
     return updated || 0
   }
-
-  override async commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void> {
-    await this.cfg.downstreamDB.commitTransaction(tx, opt)
-    await this.cfg.cacheDB.commitTransaction(tx, opt)
-  }
 }