@naturalcycles/db-lib 8.60.1 → 9.1.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, DBSaveBatchOperation } 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,23 @@ 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;
+    sortRows<ROW extends ObjectWithId>(rows: ROW[]): ROW[];
     private logStarted;
     private logFinished;
 }

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

@@ -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, // todo
+        };
         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);
     }
+    // override async createTransaction(): Promise<FileDBTransaction> {
+    //   return new FileDBTransaction(this)
+    // }
     sortRows(rows) {
         rows = rows.map(r => (0, js_lib_1._filterUndefinedValues)(r));
         if (this.cfg.sortOnSave) {
@@ -198,3 +168,79 @@ class FileDB extends __1.BaseCommonDB {
     }
 }
 exports.FileDB = FileDB;
+// todo: get back and fix it
+// Implementation is optimized for loading/saving _whole files_.
+/*
+export class FileDBTransaction implements DBTransaction {
+  constructor(private db: FileDB) {}
+
+  ops: DBOperation[] = []
+
+  async commit(): Promise<void> {
+    // data[table][id] => row
+    const data: StringMap<StringMap<ObjectWithId>> = {}
+
+    // 1. Load all tables data (concurrently)
+    const tables = _uniq(this.ops.map(o => o.table))
+
+    await pMap(
+      tables,
+      async table => {
+        const rows = await this.db.loadFile(table)
+        data[table] = _by(rows, r => r.id)
+      },
+      { concurrency: 16 },
+    )
+
+    const backup = _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 as any).type}`)
+      }
+    })
+
+    // 3. Sort, turn it into ops
+    // Not filtering empty arrays, cause it's already filtered in this.saveFiles()
+    const ops: DBSaveBatchOperation[] = _stringMapEntries(data).map(([table, map]) => {
+      return {
+        type: 'saveBatch',
+        table,
+        rows: this.db.sortRows(_stringMapValues(map)),
+      }
+    })
+
+    // 4. Save all files
+    try {
+      await this.db.saveFiles(ops)
+    } catch (err) {
+      const ops: DBSaveBatchOperation[] = _stringMapEntries(backup).map(([table, map]) => {
+        return {
+          type: 'saveBatch',
+          table,
+          rows: this.db.sortRows(_stringMapValues(map)),
+        }
+      })
+
+      // Rollback, ignore rollback error (if any)
+      await this.db.saveFiles(ops).catch(_ => {})
+
+      throw err
+    }
+  }
+
+  async rollback(): Promise<void> {
+    this.ops = []
+  }
+}
+*/

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, DBTransactionFn } 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>>;
@@ -55,11 +73,12 @@ export declare class InMemoryDB implements CommonDB {
     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>;
+    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>;
+    runInTransaction(fn: DBTransactionFn): Promise<void>;
     /**
      * Flushes all tables (all namespaces) at once.
      */
@@ -69,3 +88,13 @@ export declare class InMemoryDB implements CommonDB {
      */
     restoreFromDisk(): Promise<void>;
 }
+export declare class InMemoryDBTransaction implements DBTransaction {
+    private db;
+    constructor(db: InMemoryDB);
+    ops: DBOperation[];
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
+    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 = {
@@ -95,12 +98,20 @@ class InMemoryDB {
     }
     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);
+        return await this.deleteByIds(q.table, ids);
+    }
+    async deleteByIds(_table, ids, _opt) {
+        const table = this.cfg.tablesPrefix + _table;
+        if (!this.data[table])
+            return 0;
         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;
@@ -135,28 +146,14 @@ 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);
+    async runInTransaction(fn) {
+        const tx = new InMemoryDBTransaction(this);
         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}`);
-                }
-            }
+            await fn(tx);
+            await tx.commit();
         }
         catch (err) {
-            // rollback
-            this.data = backup;
-            this.cfg.logger.log('InMemoryDB transaction rolled back');
+            await tx.rollback();
             throw err;
         }
     }
@@ -215,3 +212,57 @@ class InMemoryDB {
     }
 }
 exports.InMemoryDB = InMemoryDB;
+class InMemoryDBTransaction {
+    constructor(db) {
+        this.db = db;
+        this.ops = [];
+    }
+    async getByIds(table, ids, opt) {
+        return await this.db.getByIds(table, ids, opt);
+    }
+    async saveBatch(table, rows, opt) {
+        this.ops.push({
+            type: 'saveBatch',
+            table,
+            rows,
+            opt,
+        });
+    }
+    async deleteByIds(table, ids, opt) {
+        this.ops.push({
+            type: 'deleteByIds',
+            table,
+            ids,
+            opt,
+        });
+        return ids.length;
+    }
+    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.ops = [];
+            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, DBTransactionFn, 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>;
+    runInTransaction(fn: DBTransactionFn): Promise<void>;
 }

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,13 @@ 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 runInTransaction(fn) {
+        const tx = new dbTransaction_util_1.FakeDBTransaction(this);
+        await fn(tx);
+        // there's no try/catch and rollback, as there's nothing to rollback
     }
 }
 exports.BaseCommonDB = BaseCommonDB;

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 type { ReadableTyped } from '@naturalcycles/nodejs-lib';
+import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, DBPatch, DBTransactionFn, 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.
@@ -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).
@@ -69,6 +100,31 @@ export interface CommonDB {
     /**
      * Should be implemented as a Transaction (best effort), which means that
      * either ALL or NONE of the operations should be applied.
+     *
+     * Transaction is automatically committed if fn resolves normally.
+     * Transaction is rolled back if fn throws, the error is re-thrown in that case.
+     * Graceful rollback is allowed on tx.rollback()
      */
-    commitTransaction: (tx: DBTransaction, opt?: CommonDBOptions) => Promise<void>;
+    runInTransaction: (fn: DBTransactionFn) => Promise<void>;
+}
+/**
+ * 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;