@naturalcycles/db-lib 10.0.2 → 10.1.1

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

@@ -1,14 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryDBTransaction = exports.InMemoryDB = void 0;
-const node_stream_1 = require("node:stream");
-const js_lib_1 = require("@naturalcycles/js-lib");
-const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
-const __1 = require("../..");
-class InMemoryDB {
-    dbType = __1.CommonDBType.document;
+import { Readable } from 'node:stream';
+import { _assert, _by, _deepCopy, _isEmptyObject, _since, _sortObjectDeep, _stringMapEntries, _stringMapValues, generateJsonSchemaFromData, localTime, pMap, } from '@naturalcycles/js-lib';
+import { _pipeline, bufferReviver, dimGrey, fs2, yellow } from '@naturalcycles/nodejs-lib';
+import { commonDBFullSupport, CommonDBType } from '../../common.db.js';
+import { queryInMemory } from './queryInMemory.js';
+export class InMemoryDB {
+    dbType = CommonDBType.document;
     support = {
-        ...__1.commonDBFullSupport,
+        ...commonDBFullSupport,
         timeMachine: false,
     };
     constructor(cfg) {
@@ -31,7 +29,7 @@ class InMemoryDB {
      * Deterministic - jsonSorted.
      */
     getDataSnapshot() {
-        return (0, js_lib_1._sortObjectDeep)(this.data);
+        return _sortObjectDeep(this.data);
     }
     async ping() { }
     /**
@@ -57,7 +55,7 @@ class InMemoryDB {
     async getTableSchema(_table) {
         const table = this.cfg.tablesPrefix + _table;
         return {
-            ...(0, js_lib_1.generateJsonSchemaFromData)((0, js_lib_1._stringMapValues)(this.data[table] || {})),
+            ...generateJsonSchemaFromData(_stringMapValues(this.data[table] || {})),
             $id: `${table}.schema.json`,
         };
     }
@@ -92,14 +90,14 @@ class InMemoryDB {
             // JSON parse/stringify (deep clone) is to:
             // 1. Not store values "by reference" (avoid mutation bugs)
             // 2. Simulate real DB that would do something like that in a transport layer anyway
-            this.data[table][r.id] = JSON.parse(JSON.stringify(r), nodejs_lib_1.bufferReviver);
+            this.data[table][r.id] = JSON.parse(JSON.stringify(r), bufferReviver);
         });
     }
     async deleteByQuery(q, _opt) {
         const table = this.cfg.tablesPrefix + q.table;
         if (!this.data[table])
             return 0;
-        const ids = (0, __1.queryInMemory)(q, Object.values(this.data[table])).map(r => r.id);
+        const ids = queryInMemory(q, Object.values(this.data[table])).map(r => r.id);
         return await this.deleteByIds(q.table, ids);
     }
     async deleteByIds(_table, ids, _opt) {
@@ -116,24 +114,24 @@ class InMemoryDB {
         return count;
     }
     async patchByQuery(q, patch) {
-        if ((0, js_lib_1._isEmptyObject)(patch))
+        if (_isEmptyObject(patch))
             return 0;
         const table = this.cfg.tablesPrefix + q.table;
-        const rows = (0, __1.queryInMemory)(q, Object.values(this.data[table] || {}));
+        const rows = queryInMemory(q, Object.values(this.data[table] || {}));
         rows.forEach(row => Object.assign(row, patch));
         return rows.length;
     }
     async runQuery(q, _opt) {
         const table = this.cfg.tablesPrefix + q.table;
-        return { rows: (0, __1.queryInMemory)(q, Object.values(this.data[table] || {})) };
+        return { rows: queryInMemory(q, Object.values(this.data[table] || {})) };
     }
     async runQueryCount(q, _opt) {
         const table = this.cfg.tablesPrefix + q.table;
-        return (0, __1.queryInMemory)(q, Object.values(this.data[table] || {})).length;
+        return queryInMemory(q, Object.values(this.data[table] || {})).length;
     }
     streamQuery(q, _opt) {
         const table = this.cfg.tablesPrefix + q.table;
-        return node_stream_1.Readable.from((0, __1.queryInMemory)(q, Object.values(this.data[table] || {})));
+        return Readable.from(queryInMemory(q, Object.values(this.data[table] || {})));
     }
     async runInTransaction(fn, opt = {}) {
         const tx = new InMemoryDBTransaction(this, {
@@ -149,11 +147,17 @@ class InMemoryDB {
             throw err;
         }
     }
+    async createTransaction(opt = {}) {
+        return new InMemoryDBTransaction(this, {
+            readOnly: false,
+            ...opt,
+        });
+    }
     async incrementBatch(table, prop, incrementMap, _opt) {
         const tbl = this.cfg.tablesPrefix + table;
         this.data[tbl] ||= {};
         const result = {};
-        for (const [id, by] of (0, js_lib_1._stringMapEntries)(incrementMap)) {
+        for (const [id, by] of _stringMapEntries(incrementMap)) {
             this.data[tbl][id] ||= { id };
             const newValue = (this.data[tbl][id][prop] || 0) + by;
             this.data[tbl][id][prop] = newValue;
@@ -165,44 +169,43 @@ class InMemoryDB {
      * Flushes all tables (all namespaces) at once.
      */
     async flushToDisk() {
-        (0, js_lib_1._assert)(this.cfg.persistenceEnabled, 'flushToDisk() called but persistenceEnabled=false');
+        _assert(this.cfg.persistenceEnabled, 'flushToDisk() called but persistenceEnabled=false');
         const { persistentStoragePath, persistZip } = this.cfg;
-        const started = js_lib_1.localTime.nowUnixMillis();
-        await nodejs_lib_1.fs2.emptyDirAsync(persistentStoragePath);
+        const started = localTime.nowUnixMillis();
+        await fs2.emptyDirAsync(persistentStoragePath);
         let tables = 0;
         // infinite concurrency for now
-        await (0, js_lib_1.pMap)(Object.keys(this.data), async (table) => {
+        await pMap(Object.keys(this.data), async (table) => {
             const rows = Object.values(this.data[table]);
             if (rows.length === 0)
                 return; // 0 rows
             tables++;
             const fname = `${persistentStoragePath}/${table}.ndjson${persistZip ? '.gz' : ''}`;
-            await (0, nodejs_lib_1._pipeline)([node_stream_1.Readable.from(rows), ...nodejs_lib_1.fs2.createWriteStreamAsNDJSON(fname)]);
+            await _pipeline([Readable.from(rows), ...fs2.createWriteStreamAsNDJSON(fname)]);
         });
-        this.cfg.logger.log(`flushToDisk took ${(0, nodejs_lib_1.dimGrey)((0, js_lib_1._since)(started))} to save ${(0, nodejs_lib_1.yellow)(tables)} tables`);
+        this.cfg.logger.log(`flushToDisk took ${dimGrey(_since(started))} to save ${yellow(tables)} tables`);
     }
     /**
      * Restores all tables (all namespaces) at once.
      */
     async restoreFromDisk() {
-        (0, js_lib_1._assert)(this.cfg.persistenceEnabled, 'restoreFromDisk() called but persistenceEnabled=false');
+        _assert(this.cfg.persistenceEnabled, 'restoreFromDisk() called but persistenceEnabled=false');
         const { persistentStoragePath } = this.cfg;
-        const started = js_lib_1.localTime.nowUnixMillis();
-        await nodejs_lib_1.fs2.ensureDirAsync(persistentStoragePath);
+        const started = localTime.nowUnixMillis();
+        await fs2.ensureDirAsync(persistentStoragePath);
         this.data = {}; // empty it in the beginning!
-        const files = (await nodejs_lib_1.fs2.readdirAsync(persistentStoragePath)).filter(f => f.includes('.ndjson'));
+        const files = (await fs2.readdirAsync(persistentStoragePath)).filter(f => f.includes('.ndjson'));
         // infinite concurrency for now
-        await (0, js_lib_1.pMap)(files, async (file) => {
+        await pMap(files, async (file) => {
             const fname = `${persistentStoragePath}/${file}`;
             const table = file.split('.ndjson')[0];
-            const rows = await nodejs_lib_1.fs2.createReadStreamAsNDJSON(fname).toArray();
-            this.data[table] = (0, js_lib_1._by)(rows, r => r.id);
+            const rows = await fs2.createReadStreamAsNDJSON(fname).toArray();
+            this.data[table] = _by(rows, r => r.id);
         });
-        this.cfg.logger.log(`restoreFromDisk took ${(0, nodejs_lib_1.dimGrey)((0, js_lib_1._since)(started))} to read ${(0, nodejs_lib_1.yellow)(files.length)} tables`);
+        this.cfg.logger.log(`restoreFromDisk took ${dimGrey(_since(started))} to read ${yellow(files.length)} tables`);
     }
 }
-exports.InMemoryDB = InMemoryDB;
-class InMemoryDBTransaction {
+export class InMemoryDBTransaction {
     db;
     opt;
     constructor(db, opt) {
@@ -214,12 +217,12 @@ class InMemoryDBTransaction {
     writeOperationHappened = false;
     async getByIds(table, ids, opt) {
         if (this.db.cfg.forbidTransactionReadAfterWrite) {
-            (0, js_lib_1._assert)(!this.writeOperationHappened, `InMemoryDBTransaction: read operation attempted after write operation`);
+            _assert(!this.writeOperationHappened, `InMemoryDBTransaction: read operation attempted after write operation`);
         }
         return await this.db.getByIds(table, ids, opt);
     }
     async saveBatch(table, rows, opt) {
-        (0, js_lib_1._assert)(!this.opt.readOnly, `InMemoryDBTransaction: saveBatch(${table}) called in readOnly mode`);
+        _assert(!this.opt.readOnly, `InMemoryDBTransaction: saveBatch(${table}) called in readOnly mode`);
         this.writeOperationHappened = true;
         this.ops.push({
             type: 'saveBatch',
@@ -229,7 +232,7 @@ class InMemoryDBTransaction {
         });
     }
     async deleteByIds(table, ids, opt) {
-        (0, js_lib_1._assert)(!this.opt.readOnly, `InMemoryDBTransaction: deleteByIds(${table}) called in readOnly mode`);
+        _assert(!this.opt.readOnly, `InMemoryDBTransaction: deleteByIds(${table}) called in readOnly mode`);
         this.writeOperationHappened = true;
         this.ops.push({
             type: 'deleteByIds',
@@ -240,7 +243,7 @@ class InMemoryDBTransaction {
         return ids.length;
     }
     async commit() {
-        const backup = (0, js_lib_1._deepCopy)(this.db.data);
+        const backup = _deepCopy(this.db.data);
         try {
             for (const op of this.ops) {
                 if (op.type === 'saveBatch') {
@@ -267,4 +270,3 @@ class InMemoryDBTransaction {
         this.ops = [];
     }
 }
-exports.InMemoryDBTransaction = InMemoryDBTransaction;

package/dist/adapter/inmemory/inMemoryKeyValueDB.d.ts

@@ -1,7 +1,7 @@
 import type { StringMap } from '@naturalcycles/js-lib';
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import type { CommonDBCreateOptions } from '../../db.model';
-import type { CommonKeyValueDB, IncrementTuple, KeyValueDBTuple } from '../../kv/commonKeyValueDB';
+import type { CommonDBCreateOptions } from '../../db.model.js';
+import type { CommonKeyValueDB, IncrementTuple, KeyValueDBTuple } from '../../kv/commonKeyValueDB.js';
 export interface InMemoryKeyValueDBCfg {
 }
 export declare class InMemoryKeyValueDB implements CommonKeyValueDB {

package/dist/adapter/inmemory/inMemoryKeyValueDB.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryKeyValueDB = void 0;
-const node_stream_1 = require("node:stream");
-const commonKeyValueDB_1 = require("../../kv/commonKeyValueDB");
-class InMemoryKeyValueDB {
+import { Readable } from 'node:stream';
+import { commonKeyValueDBFullSupport } from '../../kv/commonKeyValueDB.js';
+export class InMemoryKeyValueDB {
     cfg;
     constructor(cfg = {}) {
         this.cfg = cfg;
     }
     support = {
-        ...commonKeyValueDB_1.commonKeyValueDBFullSupport,
+        ...commonKeyValueDBFullSupport,
     };
     // data[table][id] => any (can be Buffer, or number)
     data = {};
@@ -28,13 +25,13 @@ class InMemoryKeyValueDB {
         entries.forEach(([id, v]) => (this.data[table][id] = v));
     }
     streamIds(table, limit) {
-        return node_stream_1.Readable.from(Object.keys(this.data[table] || {}).slice(0, limit));
+        return Readable.from(Object.keys(this.data[table] || {}).slice(0, limit));
     }
     streamValues(table, limit) {
-        return node_stream_1.Readable.from(Object.values(this.data[table] || {}).slice(0, limit));
+        return Readable.from(Object.values(this.data[table] || {}).slice(0, limit));
     }
     streamEntries(table, limit) {
-        return node_stream_1.Readable.from(Object.entries(this.data[table] || {}).slice(0, limit));
+        return Readable.from(Object.entries(this.data[table] || {}).slice(0, limit));
     }
     async count(table) {
         this.data[table] ||= {};
@@ -49,4 +46,3 @@ class InMemoryKeyValueDB {
         });
     }
 }
-exports.InMemoryKeyValueDB = InMemoryKeyValueDB;

package/dist/adapter/inmemory/queryInMemory.d.ts

@@ -1,3 +1,3 @@
 import type { ObjectWithId } from '@naturalcycles/js-lib';
-import type { DBQuery } from '../../query/dbQuery';
+import type { DBQuery } from '../../query/dbQuery.js';
 export declare function queryInMemory<ROW extends ObjectWithId>(q: DBQuery<ROW>, rows?: ROW[]): ROW[];

package/dist/adapter/inmemory/queryInMemory.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.queryInMemory = queryInMemory;
-const js_lib_1 = require("@naturalcycles/js-lib");
+import { _get, _pick } from '@naturalcycles/js-lib';
 const FILTER_FNS = {
     '==': (v, val) => v === val,
     '!=': (v, val) => v !== val,
@@ -16,18 +13,18 @@ const FILTER_FNS = {
 };
 // Important: q.table is not used in this function, so tablesPrefix is not needed.
 // But should be careful here..
-function queryInMemory(q, rows = []) {
+export function queryInMemory(q, rows = []) {
     // .filter
     // eslint-disable-next-line unicorn/no-array-reduce
     rows = q._filters.reduce((rows, filter) => {
         return rows.filter(row => {
-            const value = (0, js_lib_1._get)(row, filter.name);
+            const value = _get(row, filter.name);
             return FILTER_FNS[filter.op](value, filter.val);
         });
     }, rows);
     // .select(fieldNames)
     if (q._selectedFieldNames) {
-        rows = rows.map(row => (0, js_lib_1._pick)(row, q._selectedFieldNames));
+        rows = rows.map(row => _pick(row, q._selectedFieldNames));
     }
     // todo: only one order is supported (first)
     const [order] = q._orders;

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

@@ -1,9 +1,9 @@
 import type { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, StringMap } from '@naturalcycles/js-lib';
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import type { CommonDB, CommonDBSupport } from './common.db';
-import { CommonDBType } from './common.db';
-import type { CommonDBOptions, CommonDBSaveOptions, CommonDBTransactionOptions, DBTransactionFn, RunQueryResult } from './db.model';
-import type { DBQuery } from './query/dbQuery';
+import type { CommonDB, CommonDBSupport } from './common.db.js';
+import { CommonDBType } from './common.db.js';
+import type { CommonDBOptions, CommonDBSaveOptions, CommonDBTransactionOptions, DBTransaction, DBTransactionFn, RunQueryResult } from './db.model.js';
+import type { DBQuery } from './query/dbQuery.js';
 /**
  * No-op implementation of CommonDB interface.
  * To be extended by actual implementations.
@@ -24,5 +24,6 @@ export declare class BaseCommonDB implements CommonDB {
     streamQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): ReadableTyped<ROW>;
     deleteByIds(_table: string, _ids: string[], _opt?: CommonDBOptions): Promise<number>;
     runInTransaction(fn: DBTransactionFn, _opt?: CommonDBTransactionOptions): Promise<void>;
+    createTransaction(_opt?: CommonDBTransactionOptions): Promise<DBTransaction>;
     incrementBatch(_table: string, _prop: string, _incrementMap: StringMap<number>, _opt?: CommonDBOptions): Promise<StringMap<number>>;
 }

package/dist/base.common.db.js

@@ -1,14 +1,11 @@
-"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");
+import { CommonDBType } from './common.db.js';
+import { FakeDBTransaction } from './transaction/dbTransaction.util.js';
 /**
  * No-op implementation of CommonDB interface.
  * To be extended by actual implementations.
  */
-class BaseCommonDB {
-    dbType = common_db_1.CommonDBType.document;
+export class BaseCommonDB {
+    dbType = CommonDBType.document;
     support = {};
     async ping() {
         throw new Error('ping is not implemented');
@@ -47,12 +44,14 @@ class BaseCommonDB {
         throw new Error('deleteByIds is not implemented');
     }
     async runInTransaction(fn, _opt) {
-        const tx = new dbTransaction_util_1.FakeDBTransaction(this);
+        const tx = new FakeDBTransaction(this);
         await fn(tx);
         // there's no try/catch and rollback, as there's nothing to rollback
     }
+    async createTransaction(_opt) {
+        return new FakeDBTransaction(this);
+    }
     async incrementBatch(_table, _prop, _incrementMap, _opt) {
         throw new Error('incrementBatch is not implemented');
     }
 }
-exports.BaseCommonDB = BaseCommonDB;

package/dist/cnst.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DBLibError = void 0;
-var DBLibError;
+export var DBLibError;
 (function (DBLibError) {
     DBLibError["DB_ROW_REQUIRED"] = "DB_ROW_REQUIRED";
     DBLibError["DAO_IS_READ_ONLY"] = "DAO_IS_READ_ONLY";
     DBLibError["NON_UNIQUE_ID"] = "NON_UNIQUE_ID";
     DBLibError["OBJECT_IS_IMMUTABLE"] = "OBJECT_IS_IMMUTABLE";
-})(DBLibError || (exports.DBLibError = DBLibError = {}));
+})(DBLibError || (DBLibError = {}));

package/dist/common.db.d.ts

@@ -1,7 +1,7 @@
 import type { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, StringMap } from '@naturalcycles/js-lib';
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import type { CommonDBCreateOptions, CommonDBOptions, CommonDBReadOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBTransactionOptions, DBTransactionFn, RunQueryResult } from './db.model';
-import type { DBQuery } from './query/dbQuery';
+import type { CommonDBCreateOptions, CommonDBOptions, CommonDBReadOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBTransactionOptions, DBTransaction, DBTransactionFn, RunQueryResult } from './db.model.js';
+import type { DBQuery } from './query/dbQuery.js';
 export declare enum CommonDBType {
     'document' = "document",
     'relational' = "relational"
@@ -87,6 +87,12 @@ export interface CommonDB {
      * unless specified as readOnly in CommonDBTransactionOptions.
      */
     runInTransaction: (fn: DBTransactionFn, opt?: CommonDBTransactionOptions) => Promise<void>;
+    /**
+     * Experimental API to support more manual transaction control.
+     *
+     * @experimental
+     */
+    createTransaction: (opt?: CommonDBTransactionOptions) => Promise<DBTransaction>;
     /**
      * Increments a value of a property by a given amount.
      * This is a batch operation, so it allows to increment multiple rows at once.

package/dist/common.db.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.commonDBFullSupport = exports.CommonDBType = void 0;
-var CommonDBType;
+export var CommonDBType;
 (function (CommonDBType) {
     CommonDBType["document"] = "document";
     CommonDBType["relational"] = "relational";
-})(CommonDBType || (exports.CommonDBType = CommonDBType = {}));
-exports.commonDBFullSupport = {
+})(CommonDBType || (CommonDBType = {}));
+export const commonDBFullSupport = {
     queries: true,
     dbQueryFilter: true,
     dbQueryFilterIn: true,

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

@@ -3,10 +3,10 @@ import type { AsyncMapper, BaseDBEntity, CommonLogger, JsonSchemaObject, JsonSch
 import { ZodSchema } from '@naturalcycles/js-lib/dist/zod/index.js';
 import type { ObjectSchema, ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { AjvSchema } from '@naturalcycles/nodejs-lib';
-import type { CommonDBTransactionOptions, DBTransaction, RunQueryResult } from '../db.model';
-import type { DBQuery } from '../query/dbQuery';
-import { RunnableDBQuery } from '../query/dbQuery';
-import type { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoPatchByIdOptions, CommonDaoPatchOptions, CommonDaoReadOptions, CommonDaoSaveBatchOptions, CommonDaoSaveOptions, CommonDaoStreamDeleteOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDaoStreamSaveOptions } from './common.dao.model';
+import type { CommonDBTransactionOptions, DBTransaction, RunQueryResult } from '../db.model.js';
+import type { DBQuery } from '../query/dbQuery.js';
+import { RunnableDBQuery } from '../query/dbQuery.js';
+import type { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoPatchByIdOptions, CommonDaoPatchOptions, CommonDaoReadOptions, CommonDaoSaveBatchOptions, CommonDaoSaveOptions, CommonDaoStreamDeleteOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDaoStreamSaveOptions } from './common.dao.model.js';
 /**
  * Lowest common denominator API between supported Databases.
  *
@@ -168,6 +168,7 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * Proxy to this.cfg.db.ping
      */
     ping(): Promise<void>;
+    createTransaction(opt?: CommonDBTransactionOptions): Promise<CommonDaoTransaction>;
     runInTransaction<T = void>(fn: CommonDaoTransactionFn<T>, opt?: CommonDBTransactionOptions): Promise<T>;
     /**
      * Throws if query uses a property that is in `excludeFromIndexes` list.
@@ -192,8 +193,14 @@ export declare class CommonDaoTransaction {
     tx: DBTransaction;
     private logger;
     constructor(tx: DBTransaction, logger: CommonLogger);
+    /**
+     * Commits the underlying DBTransaction.
+     * May throw.
+     */
+    commit(): Promise<void>;
     /**
      * Perform a graceful rollback without throwing/re-throwing any error.
+     * Never throws.
      */
     rollback(): Promise<void>;
     getById<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(dao: CommonDao<BM, DBM, ID>, id?: ID | null, opt?: CommonDaoReadOptions): Promise<BM | null>;