@naturalcycles/db-lib 8.60.1 → 9.0.0

package/dist/adapter/cachedb/cache.db.d.ts

@@ -2,10 +2,9 @@
 import { Readable } from 'node:stream';
 import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { BaseCommonDB } from '../../base.common.db';
-import { CommonDB } from '../../common.db';
-import { CommonDBOptions, DBPatch, RunQueryResult } from '../../db.model';
+import { CommonDB, CommonDBSupport } from '../../common.db';
+import { DBPatch, RunQueryResult } from '../../db.model';
 import { DBQuery } from '../../query/dbQuery';
-import { DBTransaction } from '../../transaction/dbTransaction';
 import { CacheDBCfg, CacheDBCreateOptions, CacheDBOptions, CacheDBSaveOptions, CacheDBStreamOptions } from './cache.db.model';
 /**
  * CommonDB implementation that proxies requests to downstream CommonDB
@@ -14,6 +13,7 @@ import { CacheDBCfg, CacheDBCreateOptions, CacheDBOptions, CacheDBSaveOptions, C
  * Queries always hit downstream (unless `onlyCache` is passed)
  */
 export declare class CacheDB extends BaseCommonDB implements CommonDB {
+    support: CommonDBSupport;
     constructor(cfg: CacheDBCfg);
     cfg: CacheDBCfg;
     ping(): Promise<void>;
@@ -30,5 +30,4 @@ export declare class CacheDB extends BaseCommonDB implements CommonDB {
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBStreamOptions): Readable;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
     updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CacheDBOptions): Promise<number>;
-    commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void>;
 }

package/dist/adapter/cachedb/cache.db.js

@@ -4,6 +4,7 @@ exports.CacheDB = void 0;
 const node_stream_1 = require("node:stream");
 const js_lib_1 = require("@naturalcycles/js-lib");
 const base_common_db_1 = require("../../base.common.db");
+const common_db_1 = require("../../common.db");
 /**
  * CommonDB implementation that proxies requests to downstream CommonDB
  * and does in-memory caching.
@@ -13,6 +14,10 @@ const base_common_db_1 = require("../../base.common.db");
 class CacheDB extends base_common_db_1.BaseCommonDB {
     constructor(cfg) {
         super();
+        this.support = {
+            ...common_db_1.commonDBFullSupport,
+            transactions: false,
+        };
         this.cfg = {
             logger: console,
             ...cfg,
@@ -187,9 +192,5 @@ class CacheDB extends base_common_db_1.BaseCommonDB {
         }
         return updated || 0;
     }
-    async commitTransaction(tx, opt) {
-        await this.cfg.downstreamDB.commitTransaction(tx, opt);
-        await this.cfg.cacheDB.commitTransaction(tx, opt);
-    }
 }
 exports.CacheDB = CacheDB;

package/dist/adapter/cachedb/cache.db.model.d.ts

@@ -1,6 +1,6 @@
 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;
     cacheDB: CommonDB;
@@ -37,7 +37,7 @@ export interface CacheDBCfg {
      */
     logger?: CommonLogger;
 }
-export interface CacheDBOptions {
+export interface CacheDBOptions extends CommonDBOptions {
     /**
      * @default false
      */

package/dist/adapter/file/file.db.d.ts

@@ -1,10 +1,9 @@
 import { JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { BaseCommonDB, DBSaveBatchOperation } from '../..';
+import { BaseCommonDB, CommonDBSupport, DBOperation, DBSaveBatchOperation, DBTransaction } from '../..';
 import { CommonDB } from '../../common.db';
 import { CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, RunQueryResult } from '../../db.model';
 import { DBQuery } from '../../query/dbQuery';
-import { DBTransaction } from '../../transaction/dbTransaction';
 import { FileDBCfg } from './file.db.model';
 /**
  * Provides barebone implementation for "whole file" based CommonDB.
@@ -17,25 +16,34 @@ import { FileDBCfg } from './file.db.model';
  * Each save operation saves *whole* file to the persistence layer.
  */
 export declare class FileDB extends BaseCommonDB implements CommonDB {
+    support: CommonDBSupport;
     constructor(cfg: FileDBCfg);
     cfg: FileDBCfg;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
     getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
     saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    /**
-     * Implementation is optimized for loading/saving _whole files_.
-     */
-    commitTransaction(tx: DBTransaction, _opt?: CommonDBOptions): Promise<void>;
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
     runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions): ReadableTyped<ROW>;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    deleteByIds(table: string, ids: string[], _opt?: CommonDBOptions): Promise<number>;
     getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
     loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
     saveFile<ROW extends ObjectWithId>(table: string, _rows: ROW[]): Promise<void>;
     saveFiles<ROW extends ObjectWithId>(ops: DBSaveBatchOperation<ROW>[]): Promise<void>;
-    private sortRows;
+    createTransaction(): Promise<FileDBTransaction>;
+    sortRows<ROW extends ObjectWithId>(rows: ROW[]): ROW[];
     private logStarted;
     private logFinished;
 }
+export declare class FileDBTransaction implements DBTransaction {
+    private db;
+    constructor(db: FileDB);
+    ops: DBOperation[];
+    /**
+     * Implementation is optimized for loading/saving _whole files_.
+     */
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}

package/dist/adapter/file/file.db.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileDB = void 0;
+exports.FileDBTransaction = exports.FileDB = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const __1 = require("../..");
@@ -17,6 +17,15 @@ const __1 = require("../..");
 class FileDB extends __1.BaseCommonDB {
     constructor(cfg) {
         super();
+        this.support = {
+            ...__1.commonDBFullSupport,
+            bufferValues: false, // todo: implement
+            insertSaveMethod: false,
+            updateSaveMethod: false,
+            updateByQuery: false,
+            createTable: false,
+            transactions: false,
+        };
         this.cfg = {
             sortObjects: true,
             logFinished: true,
@@ -57,62 +66,6 @@ class FileDB extends __1.BaseCommonDB {
             await this.saveFile(table, (0, js_lib_1._stringMapValues)(byId));
         }
     }
-    /**
-     * Implementation is optimized for loading/saving _whole files_.
-     */
-    async commitTransaction(tx, _opt) {
-        // data[table][id] => row
-        const data = {};
-        // 1. Load all tables data (concurrently)
-        const tables = (0, js_lib_1._uniq)(tx.ops.map(o => o.table));
-        await (0, js_lib_1.pMap)(tables, async (table) => {
-            const rows = await this.loadFile(table);
-            data[table] = (0, js_lib_1._by)(rows, r => r.id);
-        }, { concurrency: 16 });
-        const backup = (0, js_lib_1._deepCopy)(data);
-        // 2. Apply ops one by one (in order)
-        tx.ops.forEach(op => {
-            if (op.type === 'deleteByIds') {
-                op.ids.forEach(id => delete data[op.table][id]);
-            }
-            else if (op.type === 'saveBatch') {
-                op.rows.forEach(r => {
-                    if (!r.id) {
-                        throw new Error('FileDB: row has an empty id');
-                    }
-                    data[op.table][r.id] = r;
-                });
-            }
-            else {
-                throw new Error(`DBOperation not supported: ${op.type}`);
-            }
-        });
-        // 3. Sort, turn it into ops
-        // Not filtering empty arrays, cause it's already filtered in this.saveFiles()
-        const ops = (0, js_lib_1._stringMapEntries)(data).map(([table, map]) => {
-            return {
-                type: 'saveBatch',
-                table,
-                rows: this.sortRows((0, js_lib_1._stringMapValues)(map)),
-            };
-        });
-        // 4. Save all files
-        try {
-            await this.saveFiles(ops);
-        }
-        catch (err) {
-            const ops = (0, js_lib_1._stringMapEntries)(backup).map(([table, map]) => {
-                return {
-                    type: 'saveBatch',
-                    table,
-                    rows: this.sortRows((0, js_lib_1._stringMapValues)(map)),
-                };
-            });
-            // Rollback, ignore rollback error (if any)
-            await this.saveFiles(ops).catch(_ => { });
-            throw err;
-        }
-    }
     async runQuery(q, _opt) {
         return {
             rows: (0, __1.queryInMemory)(q, await this.loadFile(q.table)),
@@ -141,6 +94,20 @@ class FileDB extends __1.BaseCommonDB {
         }
         return deleted;
     }
+    async deleteByIds(table, ids, _opt) {
+        const byId = (0, js_lib_1._by)(await this.loadFile(table), r => r.id);
+        let deleted = 0;
+        ids.forEach(id => {
+            if (!byId[id])
+                return;
+            delete byId[id];
+            deleted++;
+        });
+        if (deleted > 0) {
+            await this.saveFile(table, (0, js_lib_1._stringMapValues)(byId));
+        }
+        return deleted;
+    }
     async getTableSchema(table) {
         const rows = await this.loadFile(table);
         return {
@@ -173,6 +140,9 @@ class FileDB extends __1.BaseCommonDB {
         await this.cfg.plugin.saveFiles(ops);
         this.logFinished(started, op);
     }
+    async createTransaction() {
+        return new FileDBTransaction(this);
+    }
     sortRows(rows) {
         rows = rows.map(r => (0, js_lib_1._filterUndefinedValues)(r));
         if (this.cfg.sortOnSave) {
@@ -198,3 +168,69 @@ class FileDB extends __1.BaseCommonDB {
     }
 }
 exports.FileDB = FileDB;
+class FileDBTransaction {
+    constructor(db) {
+        this.db = db;
+        this.ops = [];
+    }
+    /**
+     * Implementation is optimized for loading/saving _whole files_.
+     */
+    async commit() {
+        // data[table][id] => row
+        const data = {};
+        // 1. Load all tables data (concurrently)
+        const tables = (0, js_lib_1._uniq)(this.ops.map(o => o.table));
+        await (0, js_lib_1.pMap)(tables, async (table) => {
+            const rows = await this.db.loadFile(table);
+            data[table] = (0, js_lib_1._by)(rows, r => r.id);
+        }, { concurrency: 16 });
+        const backup = (0, js_lib_1._deepCopy)(data);
+        // 2. Apply ops one by one (in order)
+        this.ops.forEach(op => {
+            if (op.type === 'deleteByIds') {
+                op.ids.forEach(id => delete data[op.table][id]);
+            }
+            else if (op.type === 'saveBatch') {
+                op.rows.forEach(r => {
+                    if (!r.id) {
+                        throw new Error('FileDB: row has an empty id');
+                    }
+                    data[op.table][r.id] = r;
+                });
+            }
+            else {
+                throw new Error(`DBOperation not supported: ${op.type}`);
+            }
+        });
+        // 3. Sort, turn it into ops
+        // Not filtering empty arrays, cause it's already filtered in this.saveFiles()
+        const ops = (0, js_lib_1._stringMapEntries)(data).map(([table, map]) => {
+            return {
+                type: 'saveBatch',
+                table,
+                rows: this.db.sortRows((0, js_lib_1._stringMapValues)(map)),
+            };
+        });
+        // 4. Save all files
+        try {
+            await this.db.saveFiles(ops);
+        }
+        catch (err) {
+            const ops = (0, js_lib_1._stringMapEntries)(backup).map(([table, map]) => {
+                return {
+                    type: 'saveBatch',
+                    table,
+                    rows: this.db.sortRows((0, js_lib_1._stringMapValues)(map)),
+                };
+            });
+            // Rollback, ignore rollback error (if any)
+            await this.db.saveFiles(ops).catch(_ => { });
+            throw err;
+        }
+    }
+    async rollback() {
+        this.ops = [];
+    }
+}
+exports.FileDBTransaction = FileDBTransaction;

package/dist/adapter/inmemory/inMemory.db.d.ts

@@ -1,7 +1,7 @@
 import { JsonSchemaObject, StringMap, JsonSchemaRootObject, ObjectWithId, CommonLogger } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { CommonDB, DBPatch, DBTransaction } from '../..';
-import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, RunQueryResult } from '../../db.model';
+import { CommonDB, CommonDBType, DBOperation, DBPatch } from '../..';
+import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, DBTransaction, RunQueryResult } from '../../db.model';
 import { DBQuery } from '../../query/dbQuery';
 export interface InMemoryDBCfg {
     /**
@@ -36,6 +36,24 @@ export interface InMemoryDBCfg {
     logger?: CommonLogger;
 }
 export declare class InMemoryDB implements CommonDB {
+    dbType: CommonDBType;
+    support: {
+        queries?: boolean | undefined;
+        dbQueryFilter?: boolean | undefined;
+        dbQueryFilterIn?: boolean | undefined;
+        dbQueryOrder?: boolean | undefined;
+        dbQuerySelectFields?: boolean | undefined;
+        insertSaveMethod?: boolean | undefined;
+        updateSaveMethod?: boolean | undefined;
+        updateByQuery?: boolean | undefined;
+        dbIncrement?: boolean | undefined;
+        createTable?: boolean | undefined;
+        tableSchemas?: boolean | undefined;
+        streaming?: boolean | undefined;
+        bufferValues?: boolean | undefined;
+        nullValues?: boolean | undefined;
+        transactions?: boolean | undefined;
+    };
     constructor(cfg?: Partial<InMemoryDBCfg>);
     cfg: InMemoryDBCfg;
     data: StringMap<StringMap<ObjectWithId>>;
@@ -54,12 +72,13 @@ export declare class InMemoryDB implements CommonDB {
     createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
     getByIds<ROW extends ObjectWithId>(_table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
     saveBatch<ROW extends Partial<ObjectWithId>>(_table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<number>;
+    deleteByIds(_table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
     updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>): Promise<number>;
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
     runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): ReadableTyped<ROW>;
-    commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void>;
+    createTransaction(): Promise<DBTransaction>;
     /**
      * Flushes all tables (all namespaces) at once.
      */
@@ -69,3 +88,10 @@ export declare class InMemoryDB implements CommonDB {
      */
     restoreFromDisk(): Promise<void>;
 }
+export declare class InMemoryDBTransaction implements DBTransaction {
+    private db;
+    constructor(db: InMemoryDB);
+    ops: DBOperation[];
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}

package/dist/adapter/inmemory/inMemory.db.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryDB = void 0;
+exports.InMemoryDBTransaction = exports.InMemoryDB = void 0;
 const tslib_1 = require("tslib");
 const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
 const promises_1 = tslib_1.__importDefault(require("node:fs/promises"));
@@ -9,9 +9,12 @@ const node_zlib_1 = require("node:zlib");
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const __1 = require("../..");
-const dbQuery_1 = require("../../query/dbQuery");
 class InMemoryDB {
     constructor(cfg) {
+        this.dbType = __1.CommonDBType.document;
+        this.support = {
+            ...__1.commonDBFullSupport,
+        };
         // data[table][id] > {id: 'a', created: ... }
         this.data = {};
         this.cfg = {
@@ -74,6 +77,17 @@ class InMemoryDB {
         return ids.map(id => this.data[table][id]).filter(Boolean);
     }
     async saveBatch(_table, rows, opt = {}) {
+        const { tx } = opt;
+        if (tx) {
+            ;
+            tx.ops.push({
+                type: 'saveBatch',
+                table: _table,
+                rows,
+                opt: (0, js_lib_1._omit)(opt, ['tx']),
+            });
+            return;
+        }
         const table = this.cfg.tablesPrefix + _table;
         this.data[table] ||= {};
         rows.forEach(r => {
@@ -93,14 +107,44 @@ class InMemoryDB {
             this.data[table][r.id] = JSON.parse(JSON.stringify(r), nodejs_lib_1.bufferReviver);
         });
     }
-    async deleteByQuery(q, _opt) {
+    async deleteByQuery(q, opt = {}) {
         const table = this.cfg.tablesPrefix + q.table;
-        this.data[table] ||= {};
+        if (!this.data[table])
+            return 0;
+        const ids = (0, __1.queryInMemory)(q, Object.values(this.data[table])).map(r => r.id);
+        const { tx } = opt;
+        if (tx) {
+            ;
+            tx.ops.push({
+                type: 'deleteByIds',
+                table: q.table,
+                ids,
+                opt: (0, js_lib_1._omit)(opt, ['tx']),
+            });
+            return ids.length;
+        }
+        return await this.deleteByIds(q.table, ids);
+    }
+    async deleteByIds(_table, ids, opt = {}) {
+        const table = this.cfg.tablesPrefix + _table;
+        if (!this.data[table])
+            return 0;
+        const { tx } = opt;
+        if (tx) {
+            ;
+            tx.ops.push({
+                type: 'deleteByIds',
+                table: _table,
+                ids,
+                opt: (0, js_lib_1._omit)(opt, ['tx']),
+            });
+            return ids.length;
+        }
         let count = 0;
-        (0, __1.queryInMemory)(q, Object.values(this.data[table] || {})).forEach(r => {
-            if (!this.data[table][r.id])
+        ids.forEach(id => {
+            if (!this.data[table][id])
                 return;
-            delete this.data[table][r.id];
+            delete this.data[table][id];
             count++;
         });
         return count;
@@ -109,6 +153,7 @@ class InMemoryDB {
         const patchEntries = Object.entries(patch);
         if (!patchEntries.length)
             return 0;
+        // todo: can we support tx here? :thinking:
         const table = this.cfg.tablesPrefix + q.table;
         const rows = (0, __1.queryInMemory)(q, Object.values(this.data[table] || {}));
         rows.forEach((row) => {
@@ -135,30 +180,8 @@ class InMemoryDB {
         const table = this.cfg.tablesPrefix + q.table;
         return node_stream_1.Readable.from((0, __1.queryInMemory)(q, Object.values(this.data[table] || {})));
     }
-    async commitTransaction(tx, opt) {
-        const backup = (0, js_lib_1._deepCopy)(this.data);
-        try {
-            for await (const op of tx.ops) {
-                if (op.type === 'saveBatch') {
-                    await this.saveBatch(op.table, op.rows, { ...op.opt, ...opt });
-                }
-                else if (op.type === 'deleteByIds') {
-                    await this.deleteByQuery(dbQuery_1.DBQuery.create(op.table).filter('id', 'in', op.ids), {
-                        ...op.opt,
-                        ...opt,
-                    });
-                }
-                else {
-                    throw new Error(`DBOperation not supported: ${op.type}`);
-                }
-            }
-        }
-        catch (err) {
-            // rollback
-            this.data = backup;
-            this.cfg.logger.log('InMemoryDB transaction rolled back');
-            throw err;
-        }
+    async createTransaction() {
+        return new InMemoryDBTransaction(this);
     }
     /**
      * Flushes all tables (all namespaces) at once.
@@ -215,3 +238,36 @@ class InMemoryDB {
     }
 }
 exports.InMemoryDB = InMemoryDB;
+class InMemoryDBTransaction {
+    constructor(db) {
+        this.db = db;
+        this.ops = [];
+    }
+    async commit() {
+        const backup = (0, js_lib_1._deepCopy)(this.db.data);
+        try {
+            for (const op of this.ops) {
+                if (op.type === 'saveBatch') {
+                    await this.db.saveBatch(op.table, op.rows, op.opt);
+                }
+                else if (op.type === 'deleteByIds') {
+                    await this.db.deleteByIds(op.table, op.ids, op.opt);
+                }
+                else {
+                    throw new Error(`DBOperation not supported: ${op.type}`);
+                }
+            }
+            this.ops = [];
+        }
+        catch (err) {
+            // rollback
+            this.db.data = backup;
+            this.db.cfg.logger.log('InMemoryDB transaction rolled back');
+            throw err;
+        }
+    }
+    async rollback() {
+        this.ops = [];
+    }
+}
+exports.InMemoryDBTransaction = InMemoryDBTransaction;

package/dist/base.common.db.d.ts

@@ -1,29 +1,26 @@
 import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { CommonDB } from './common.db';
-import { CommonDBOptions, CommonDBSaveOptions, DBPatch, RunQueryResult } from './db.model';
+import { CommonDB, CommonDBSupport, CommonDBType } from './common.db';
+import { CommonDBOptions, CommonDBSaveOptions, DBPatch, DBTransaction, RunQueryResult } from './db.model';
 import { DBQuery } from './query/dbQuery';
-import { DBTransaction } from './transaction/dbTransaction';
 /**
  * No-op implementation of CommonDB interface.
  * To be extended by actual implementations.
  */
 export declare class BaseCommonDB implements CommonDB {
+    dbType: CommonDBType;
+    support: CommonDBSupport;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
     getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
     createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>): Promise<void>;
-    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][]): Promise<ROW[]>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[]): Promise<ROW[]>;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number>;
     updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions): Promise<number>;
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<RunQueryResult<ROW>>;
     runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number>;
     saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): ReadableTyped<ROW>;
-    /**
-     * Naive implementation.
-     * Doesn't support rollback on error, hence doesn't pass dbTest.
-     * To be extended.
-     */
-    commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void>;
+    deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
+    createTransaction(): Promise<DBTransaction>;
 }

package/dist/base.common.db.js

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseCommonDB = void 0;
+const common_db_1 = require("./common.db");
+const dbTransaction_util_1 = require("./transaction/dbTransaction.util");
 /* eslint-disable unused-imports/no-unused-vars */
 /**
  * No-op implementation of CommonDB interface.
  * To be extended by actual implementations.
  */
 class BaseCommonDB {
+    constructor() {
+        this.dbType = common_db_1.CommonDBType.document;
+        this.support = {};
+    }
     async ping() {
         throw new Error('ping is not implemented');
     }
@@ -40,13 +46,11 @@ class BaseCommonDB {
     streamQuery(q) {
         throw new Error('streamQuery is not implemented');
     }
-    /**
-     * Naive implementation.
-     * Doesn't support rollback on error, hence doesn't pass dbTest.
-     * To be extended.
-     */
-    async commitTransaction(tx, opt) {
-        throw new Error('commitTransaction is not implemented');
+    async deleteByIds(table, ids, opt) {
+        throw new Error('deleteByIds is not implemented');
+    }
+    async createTransaction() {
+        return new dbTransaction_util_1.FakeDBTransaction(this);
     }
 }
 exports.BaseCommonDB = BaseCommonDB;