@naturalcycles/db-lib 9.21.0 → 9.22.1

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

@@ -2,7 +2,7 @@ import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcy
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { BaseCommonDB } from '../../base.common.db';
 import { CommonDB, CommonDBSupport } from '../../common.db';
-import { DBPatch, RunQueryResult } from '../../db.model';
+import { RunQueryResult } from '../../db.model';
 import { DBQuery } from '../../query/dbQuery';
 import { CacheDBCfg, CacheDBCreateOptions, CacheDBOptions, CacheDBSaveOptions, CacheDBStreamOptions } from './cache.db.model';
 /**
@@ -28,5 +28,5 @@ export declare class CacheDB extends BaseCommonDB implements CommonDB {
     runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBStreamOptions): ReadableTyped<ROW>;
     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>;
+    patchByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: Partial<ROW>, opt?: CacheDBOptions): Promise<number>;
 }

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

@@ -17,6 +17,7 @@ class CacheDB extends base_common_db_1.BaseCommonDB {
         this.support = {
             ...common_db_1.commonDBFullSupport,
             transactions: false,
+            increment: false,
         };
         this.cfg = {
             logger: console,
@@ -180,13 +181,13 @@ class CacheDB extends base_common_db_1.BaseCommonDB {
         }
         return deletedIds;
     }
-    async updateByQuery(q, patch, opt = {}) {
+    async patchByQuery(q, patch, opt = {}) {
         let updated;
         if (!opt.onlyCache && !this.cfg.onlyCache) {
-            updated = await this.cfg.downstreamDB.updateByQuery(q, patch, opt);
+            updated = await this.cfg.downstreamDB.patchByQuery(q, patch, opt);
         }
         if (!opt.skipCache && !this.cfg.skipCache) {
-            const cacheResult = this.cfg.cacheDB.updateByQuery(q, patch, opt);
+            const cacheResult = this.cfg.cacheDB.patchByQuery(q, patch, opt);
             if (this.cfg.awaitCache)
                 updated ??= await cacheResult;
         }

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

@@ -22,9 +22,10 @@ class FileDB extends __1.BaseCommonDB {
             bufferValues: false, // todo: implement
             insertSaveMethod: false,
             updateSaveMethod: false,
-            updateByQuery: false,
+            patchByQuery: false,
             createTable: false,
             transactions: false, // todo
+            increment: false,
         };
         this.cfg = {
             sortObjects: true,

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

@@ -1,6 +1,6 @@
-import { CommonLogger, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, StringMap } from '@naturalcycles/js-lib';
+import { AnyObjectWithId, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, StringMap } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { CommonDB, CommonDBTransactionOptions, CommonDBType, DBOperation, DBPatch, DBTransactionFn } from '../..';
+import { CommonDB, CommonDBTransactionOptions, CommonDBType, DBOperation, DBTransactionFn } from '../..';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, DBTransaction, RunQueryResult } from '../../db.model';
 import { DBQuery } from '../../query/dbQuery';
 export interface InMemoryDBCfg {
@@ -55,8 +55,8 @@ export declare class InMemoryDB implements CommonDB {
         dbQuerySelectFields?: boolean;
         insertSaveMethod?: boolean;
         updateSaveMethod?: boolean;
-        updateByQuery?: boolean;
-        dbIncrement?: boolean;
+        patchByQuery?: boolean;
+        increment?: boolean;
         createTable?: boolean;
         tableSchemas?: boolean;
         streaming?: boolean;
@@ -66,7 +66,7 @@ export declare class InMemoryDB implements CommonDB {
     };
     constructor(cfg?: Partial<InMemoryDBCfg>);
     cfg: InMemoryDBCfg;
-    data: StringMap<StringMap<ObjectWithId>>;
+    data: StringMap<StringMap<AnyObjectWithId>>;
     /**
      * Returns internal "Data snapshot".
      * Deterministic - jsonSorted.
@@ -84,11 +84,12 @@ export declare class InMemoryDB implements CommonDB {
     saveBatch<ROW extends 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>;
+    patchByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: Partial<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>;
     runInTransaction(fn: DBTransactionFn, opt?: CommonDBTransactionOptions): Promise<void>;
+    incrementBatch(table: string, prop: string, incrementMap: StringMap<number>, _opt?: CommonDBOptions): Promise<StringMap<number>>;
     /**
      * Flushes all tables (all namespaces) at once.
      */

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

@@ -113,22 +113,12 @@ class InMemoryDB {
         });
         return count;
     }
-    async updateByQuery(q, patch) {
-        const patchEntries = Object.entries(patch);
-        if (!patchEntries.length)
+    async patchByQuery(q, patch) {
+        if ((0, js_lib_1._isEmptyObject)(patch))
             return 0;
         const table = this.cfg.tablesPrefix + q.table;
         const rows = (0, __1.queryInMemory)(q, Object.values(this.data[table] || {}));
-        rows.forEach((row) => {
-            patchEntries.forEach(([k, v]) => {
-                if (v instanceof __1.DBIncrement) {
-                    row[k] = (row[k] || 0) + v.amount;
-                }
-                else {
-                    row[k] = v;
-                }
-            });
-        });
+        rows.forEach(row => Object.assign(row, patch));
         return rows.length;
     }
     async runQuery(q, _opt) {
@@ -157,6 +147,18 @@ class InMemoryDB {
             throw err;
         }
     }
+    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)) {
+            this.data[tbl][id] ||= { id };
+            const newValue = (this.data[tbl][id][prop] || 0) + by;
+            this.data[tbl][id][prop] = newValue;
+            result[id] = newValue;
+        }
+        return result;
+    }
     /**
      * Flushes all tables (all namespaces) at once.
      */

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

@@ -1,7 +1,7 @@
-import { StringMap } from '@naturalcycles/js-lib';
+import { KeyValueTuple, StringMap } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBCreateOptions } from '../../db.model';
-import { CommonKeyValueDB, KeyValueDBTuple } from '../../kv/commonKeyValueDB';
+import { CommonKeyValueDB, IncrementTuple } from '../../kv/commonKeyValueDB';
 export interface InMemoryKeyValueDBCfg {
 }
 export declare class InMemoryKeyValueDB implements CommonKeyValueDB {
@@ -11,15 +11,15 @@ export declare class InMemoryKeyValueDB implements CommonKeyValueDB {
         count?: boolean;
         increment?: boolean;
     };
-    data: StringMap<StringMap<Buffer>>;
+    data: StringMap<StringMap<any>>;
     ping(): Promise<void>;
     createTable(_table: string, _opt?: CommonDBCreateOptions): Promise<void>;
     deleteByIds(table: string, ids: string[]): Promise<void>;
-    getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]>;
-    saveBatch(table: string, entries: KeyValueDBTuple[]): Promise<void>;
+    getByIds<V>(table: string, ids: string[]): Promise<KeyValueTuple<string, V>[]>;
+    saveBatch<V>(table: string, entries: KeyValueTuple<string, V>[]): Promise<void>;
     streamIds(table: string, limit?: number): ReadableTyped<string>;
-    streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
-    streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
+    streamValues<V>(table: string, limit?: number): ReadableTyped<V>;
+    streamEntries<V>(table: string, limit?: number): ReadableTyped<KeyValueTuple<string, V>>;
     count(table: string): Promise<number>;
-    increment(table: string, id: string, by?: number): Promise<number>;
+    incrementBatch(table: string, entries: IncrementTuple[]): Promise<IncrementTuple[]>;
 }

package/dist/adapter/inmemory/inMemoryKeyValueDB.js

@@ -9,7 +9,7 @@ class InMemoryKeyValueDB {
         this.support = {
             ...commonKeyValueDB_1.commonKeyValueDBFullSupport,
         };
-        // data[table][id] > Buffer
+        // data[table][id] => V
         this.data = {};
     }
     async ping() { }
@@ -24,7 +24,7 @@ class InMemoryKeyValueDB {
     }
     async saveBatch(table, entries) {
         this.data[table] ||= {};
-        entries.forEach(([id, buf]) => (this.data[table][id] = buf));
+        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));
@@ -39,12 +39,13 @@ class InMemoryKeyValueDB {
         this.data[table] ||= {};
         return Object.keys(this.data[table]).length;
     }
-    async increment(table, id, by = 1) {
+    async incrementBatch(table, entries) {
         this.data[table] ||= {};
-        const currentValue = this.data[table][id] ? parseInt(this.data[table][id].toString()) : 0;
-        const newValue = currentValue + by;
-        this.data[table][id] = Buffer.from(String(newValue));
-        return newValue;
+        return entries.map(([id, by]) => {
+            const newValue = (this.data[table][id] || 0) + by;
+            this.data[table][id] = newValue;
+            return [id, newValue];
+        });
     }
 }
 exports.InMemoryKeyValueDB = InMemoryKeyValueDB;

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

@@ -1,7 +1,7 @@
-import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, StringMap } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDB, CommonDBSupport, CommonDBType } from './common.db';
-import { CommonDBOptions, CommonDBSaveOptions, CommonDBTransactionOptions, DBPatch, DBTransactionFn, RunQueryResult } from './db.model';
+import { CommonDBOptions, CommonDBSaveOptions, CommonDBTransactionOptions, DBTransactionFn, RunQueryResult } from './db.model';
 import { DBQuery } from './query/dbQuery';
 /**
  * No-op implementation of CommonDB interface.
@@ -16,11 +16,12 @@ export declare class BaseCommonDB implements CommonDB {
     createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>): Promise<void>;
     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>;
+    patchByQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>, _patch: Partial<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 ObjectWithId>(_table: string, _rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     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>;
+    incrementBatch(_table: string, _prop: string, _incrementMap: StringMap<number>, _opt?: CommonDBOptions): Promise<StringMap<number>>;
 }

package/dist/base.common.db.js

@@ -30,8 +30,8 @@ class BaseCommonDB {
     async deleteByQuery(_q) {
         throw new Error('deleteByQuery is not implemented');
     }
-    async updateByQuery(_q, _patch, _opt) {
-        throw new Error('updateByQuery is not implemented');
+    async patchByQuery(_q, _patch, _opt) {
+        throw new Error('patchByQuery is not implemented');
     }
     async runQuery(_q) {
         throw new Error('runQuery is not implemented');
@@ -53,5 +53,8 @@ class BaseCommonDB {
         await fn(tx);
         // there's no try/catch and rollback, as there's nothing to rollback
     }
+    async incrementBatch(_table, _prop, _incrementMap, _opt) {
+        throw new Error('incrementBatch is not implemented');
+    }
 }
 exports.BaseCommonDB = BaseCommonDB;

package/dist/common.db.d.ts

@@ -1,6 +1,6 @@
-import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, StringMap } from '@naturalcycles/js-lib';
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBTransactionOptions, DBPatch, DBTransactionFn, RunQueryResult } from './db.model';
+import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBTransactionOptions, DBTransactionFn, RunQueryResult } from './db.model';
 import { DBQuery } from './query/dbQuery';
 export declare enum CommonDBType {
     'document' = "document",
@@ -64,7 +64,7 @@ export interface CommonDB {
      */
     deleteByQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<number>;
     /**
-     * Applies patch to the rows returned by the query.
+     * Applies patch to all the rows that are matched by the query.
      *
      * Example:
      *
@@ -72,16 +72,9 @@ export interface CommonDB {
      *
      * patch would be { A: 'B' } for that query.
      *
-     * Supports "increment query", example:
-     *
-     * UPDATE table SET A = A + 1
-     *
-     * In that case patch would look like:
-     * { A: DBIncrement(1) }
-     *
-     * Returns number of rows affected.
+     * Returns the number of rows affected.
      */
-    updateByQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions) => Promise<number>;
+    patchByQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: Partial<ROW>, opt?: CommonDBOptions) => Promise<number>;
     /**
      * Should be implemented as a Transaction (best effort), which means that
      * either ALL or NONE of the operations should be applied.
@@ -94,6 +87,22 @@ export interface CommonDB {
      * unless specified as readOnly in CommonDBTransactionOptions.
      */
     runInTransaction: (fn: DBTransactionFn, opt?: CommonDBTransactionOptions) => Promise<void>;
+    /**
+     * Increments a value of a property by a given amount.
+     * This is a batch operation, so it allows to increment multiple rows at once.
+     *
+     * - table - the table to apply operations on
+     * - prop - name of the property to increment (in each of the rows passed)
+     * - incrementMap - map from id to increment value
+     *
+     * Example of incrementMap:
+     * { rowId1: 2, rowId2: 3 }
+     *
+     * Returns the incrementMap with the same keys and updated values.
+     *
+     * @experimental
+     */
+    incrementBatch: (table: string, prop: string, incrementMap: StringMap<number>, opt?: CommonDBOptions) => Promise<StringMap<number>>;
 }
 /**
  * Manifest of supported features.
@@ -106,8 +115,8 @@ export interface CommonDBSupport {
     dbQuerySelectFields?: boolean;
     insertSaveMethod?: boolean;
     updateSaveMethod?: boolean;
-    updateByQuery?: boolean;
-    dbIncrement?: boolean;
+    patchByQuery?: boolean;
+    increment?: boolean;
     createTable?: boolean;
     tableSchemas?: boolean;
     streaming?: boolean;

package/dist/common.db.js

@@ -14,8 +14,8 @@ exports.commonDBFullSupport = {
     dbQuerySelectFields: true,
     insertSaveMethod: true,
     updateSaveMethod: true,
-    updateByQuery: true,
-    dbIncrement: true,
+    patchByQuery: true,
+    increment: true,
     createTable: true,
     tableSchemas: true,
     streaming: true,

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

@@ -1,7 +1,7 @@
 import { Transform } from 'node:stream';
-import { AsyncMapper, BaseDBEntity, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, UnixTimestampMillisNumber, Unsaved, ZodSchema } from '@naturalcycles/js-lib';
+import { AsyncMapper, BaseDBEntity, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, StringMap, UnixTimestampMillisNumber, Unsaved, ZodSchema } from '@naturalcycles/js-lib';
 import { AjvSchema, ObjectSchema, ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { CommonDBTransactionOptions, DBPatch, DBTransaction, RunQueryResult } from '../db.model';
+import { CommonDBTransactionOptions, DBTransaction, RunQueryResult } from '../db.model';
 import { DBQuery, RunnableDBQuery } from '../query/dbQuery';
 import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoPatchByIdOptions, CommonDaoPatchOptions, CommonDaoSaveBatchOptions, CommonDaoSaveOptions, CommonDaoStreamDeleteOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDaoStreamSaveOptions } from './common.dao.model';
 /**
@@ -125,9 +125,20 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * This is expected to be more memory-efficient way of deleting large number of rows.
      */
     deleteByQuery(q: DBQuery<DBM>, opt?: CommonDaoStreamDeleteOptions<DBM>): Promise<number>;
-    updateById(id: ID, patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
-    updateByIds(ids: ID[], patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
-    updateByQuery(q: DBQuery<DBM>, patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
+    patchByIds(ids: ID[], patch: Partial<DBM>, opt?: CommonDaoOptions): Promise<number>;
+    patchByQuery(q: DBQuery<DBM>, patch: Partial<DBM>, opt?: CommonDaoOptions): Promise<number>;
+    /**
+     * Caveat: it doesn't update created/updated props.
+     *
+     * @experimental
+     */
+    increment(prop: keyof DBM, id: ID, by?: number, opt?: CommonDaoOptions): Promise<number>;
+    /**
+     * Caveat: it doesn't update created/updated props.
+     *
+     * @experimental
+     */
+    incrementBatch(prop: keyof DBM, incrementMap: StringMap<number>, opt?: CommonDaoOptions): Promise<StringMap<number>>;
     dbmToBM(_dbm: undefined, opt?: CommonDaoOptions): Promise<undefined>;
     dbmToBM(_dbm?: DBM, opt?: CommonDaoOptions): Promise<BM>;
     dbmsToBM(dbms: DBM[], opt?: CommonDaoOptions): Promise<BM[]>;

package/dist/commondao/common.dao.js

@@ -829,25 +829,54 @@ class CommonDao {
         this.logSaveResult(started, op, q.table);
         return deleted;
     }
-    async updateById(id, patch, opt = {}) {
-        return await this.updateByQuery(this.query().filterEq('id', id), patch, opt);
-    }
-    async updateByIds(ids, patch, opt = {}) {
+    async patchByIds(ids, patch, opt = {}) {
         if (!ids.length)
             return 0;
-        return await this.updateByQuery(this.query().filterIn('id', ids), patch, opt);
+        return await this.patchByQuery(this.query().filterIn('id', ids), patch, opt);
     }
-    async updateByQuery(q, patch, opt = {}) {
+    async patchByQuery(q, patch, opt = {}) {
         this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         this.requireWriteAccess();
         this.requireObjectMutability(opt);
         q.table = opt.table || q.table;
-        const op = `updateByQuery(${q.pretty()})`;
+        const op = `patchByQuery(${q.pretty()})`;
         const started = this.logStarted(op, q.table);
-        const updated = await this.cfg.db.updateByQuery(q, patch, opt);
+        const updated = await this.cfg.db.patchByQuery(q, patch, opt);
         this.logSaveResult(started, op, q.table);
         return updated;
     }
+    /**
+     * Caveat: it doesn't update created/updated props.
+     *
+     * @experimental
+     */
+    async increment(prop, id, by = 1, opt = {}) {
+        this.requireWriteAccess();
+        this.requireObjectMutability(opt);
+        const { table } = this.cfg;
+        const op = `increment`;
+        const started = this.logStarted(op, table);
+        const result = await this.cfg.db.incrementBatch(table, prop, {
+            [id]: by,
+        });
+        this.logSaveResult(started, op, table);
+        return result[id];
+    }
+    /**
+     * Caveat: it doesn't update created/updated props.
+     *
+     * @experimental
+     */
+    async incrementBatch(prop, incrementMap, opt = {}) {
+        this.requireWriteAccess();
+        this.requireObjectMutability(opt);
+        const { table } = this.cfg;
+        const op = `incrementBatch`;
+        const started = this.logStarted(op, table);
+        const result = await this.cfg.db.incrementBatch(table, prop, incrementMap);
+        this.logSaveResult(started, op, table);
+        return result;
+    }
     async dbmToBM(_dbm, opt = {}) {
         if (!_dbm)
             return;

package/dist/db.model.d.ts

@@ -96,16 +96,3 @@ export declare enum DBModelType {
     DBM = "DBM",
     BM = "BM"
 }
-/**
- * Allows to construct a query similar to:
- *
- * UPDATE table SET A = A + 1
- *
- * In this case DBIncement.of(1) will be needed.
- */
-export declare class DBIncrement {
-    amount: number;
-    private constructor();
-    static of(amount: number): DBIncrement;
-}
-export type DBPatch<ROW extends ObjectWithId> = Partial<Record<keyof ROW, ROW[keyof ROW] | DBIncrement>>;

package/dist/db.model.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DBIncrement = exports.DBModelType = exports.DBRelation = void 0;
+exports.DBModelType = exports.DBRelation = void 0;
 var DBRelation;
 (function (DBRelation) {
     DBRelation["ONE_TO_ONE"] = "ONE_TO_ONE";
@@ -11,19 +11,3 @@ var DBModelType;
     DBModelType["DBM"] = "DBM";
     DBModelType["BM"] = "BM";
 })(DBModelType || (exports.DBModelType = DBModelType = {}));
-/**
- * Allows to construct a query similar to:
- *
- * UPDATE table SET A = A + 1
- *
- * In this case DBIncement.of(1) will be needed.
- */
-class DBIncrement {
-    constructor(amount) {
-        this.amount = amount;
-    }
-    static of(amount) {
-        return new DBIncrement(amount);
-    }
-}
-exports.DBIncrement = DBIncrement;

package/dist/kv/commonKeyValueDB.d.ts

@@ -1,4 +1,4 @@
-import { UnixTimestampNumber } from '@naturalcycles/js-lib';
+import { Integer, KeyValueTuple, UnixTimestampNumber } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBCreateOptions } from '../db.model';
 /**
@@ -25,23 +25,31 @@ export interface CommonKeyValueDB {
      *
      * Currently it is NOT required to maintain the same order as input `ids`.
      */
-    getByIds: (table: string, ids: string[]) => Promise<KeyValueDBTuple[]>;
+    getByIds: <V>(table: string, ids: string[]) => Promise<KeyValueTuple<string, V>[]>;
     deleteByIds: (table: string, ids: string[]) => Promise<void>;
-    saveBatch: (table: string, entries: KeyValueDBTuple[], opt?: CommonKeyValueDBSaveBatchOptions) => Promise<void>;
+    saveBatch: <V>(table: string, entries: KeyValueTuple<string, V>[], opt?: CommonKeyValueDBSaveBatchOptions) => Promise<void>;
     streamIds: (table: string, limit?: number) => ReadableTyped<string>;
-    streamValues: (table: string, limit?: number) => ReadableTyped<Buffer>;
-    streamEntries: (table: string, limit?: number) => ReadableTyped<KeyValueDBTuple>;
+    streamValues: <V>(table: string, limit?: number) => ReadableTyped<V>;
+    streamEntries: <V>(table: string, limit?: number) => ReadableTyped<KeyValueTuple<string, V>>;
     count: (table: string) => Promise<number>;
     /**
+     * Perform a batch of Increment operations.
+     * Given entries array, increment each key of it (1st index of the tuple) by the given amount (2nd index of the tuple).
      *
-     * Increments the value of a key in a table by a given amount.
-     * Default increment is 1 when `by` is not provided.
+     * Example:
+     * [
+     *   ['key1', 2],
+     *   ['key2', 3],
+     * ]
+     * would increment `key1` by 2, and `key2` by 3.
      *
-     * Returns the new value.
+     * Returns the entries array with tuples of the same structure, with updated numbers.
+     *
+     * @experimental
      */
-    increment: (table: string, id: string, by?: number) => Promise<number>;
+    incrementBatch: (table: string, entries: IncrementTuple[]) => Promise<IncrementTuple[]>;
 }
-export type KeyValueDBTuple = [key: string, value: Buffer];
+export type IncrementTuple = [key: string, value: Integer];
 export interface CommonKeyValueDBSaveBatchOptions {
     /**
      * If set (and if it's implemented by the driver) - will set expiry TTL for each key of the batch.

package/dist/kv/commonKeyValueDao.d.ts

@@ -2,8 +2,8 @@ import { CommonLogger, KeyValueTuple } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDaoLogLevel } from '../commondao/common.dao.model';
 import { CommonDBCreateOptions } from '../db.model';
-import { CommonKeyValueDB, CommonKeyValueDBSaveBatchOptions, KeyValueDBTuple } from './commonKeyValueDB';
-export interface CommonKeyValueDaoCfg<V> {
+import { CommonKeyValueDB, CommonKeyValueDBSaveBatchOptions, IncrementTuple } from './commonKeyValueDB';
+export interface CommonKeyValueDaoCfg<RAW_V, V = RAW_V> {
     db: CommonKeyValueDB;
     table: string;
     /**
@@ -23,40 +23,31 @@ export interface CommonKeyValueDaoCfg<V> {
      * @default false
      */
     logStarted?: boolean;
-    hooks?: {
-        mapValueToBuffer?: (v: V) => Promise<Buffer>;
-        mapBufferToValue?: (b: Buffer) => Promise<V>;
-        beforeCreate?: (v: Partial<V>) => Partial<V>;
-    };
-    /**
-     * Set to `true` to conveniently enable zipping+JSON.stringify
-     * (and unzipping+JSON.parse) of the Buffer value via hooks.
-     * Custom hooks will override these hooks (if provided).
-     */
-    deflatedJsonValue?: boolean;
+    transformer?: CommonKeyValueDaoTransformer<V, RAW_V>;
 }
 export type CommonKeyValueDaoSaveOptions = CommonKeyValueDBSaveBatchOptions;
-export declare class CommonKeyValueDao<V, K extends string = string> {
-    constructor(cfg: CommonKeyValueDaoCfg<V>);
-    cfg: CommonKeyValueDaoCfg<V> & {
-        hooks: NonNullable<CommonKeyValueDaoCfg<V>['hooks']>;
+export interface CommonKeyValueDaoTransformer<V, RAW_V> {
+    valueToRaw: (v: V) => Promise<RAW_V>;
+    rawToValue: (raw: RAW_V) => Promise<V>;
+}
+export declare const commonKeyValueDaoDeflatedJsonTransformer: CommonKeyValueDaoTransformer<any, Buffer>;
+export declare class CommonKeyValueDao<K extends string, RAW_V, V = RAW_V> {
+    constructor(cfg: CommonKeyValueDaoCfg<RAW_V, V>);
+    cfg: CommonKeyValueDaoCfg<RAW_V, V> & {
         logger: CommonLogger;
     };
     ping(): Promise<void>;
     createTable(opt?: CommonDBCreateOptions): Promise<void>;
-    create(input?: Partial<V>): V;
     getById(id?: K): Promise<V | null>;
-    getByIdAsBuffer(id?: K): Promise<Buffer | null>;
+    getByIdRaw(id?: K): Promise<RAW_V | null>;
     requireById(id: K): Promise<V>;
-    requireByIdAsBuffer(id: K): Promise<Buffer>;
-    getByIdOrEmpty(id: K, part?: Partial<V>): Promise<V>;
-    patch(id: K, patch: Partial<V>, opt?: CommonKeyValueDaoSaveOptions): Promise<V>;
+    requireByIdRaw(id: K): Promise<RAW_V>;
     getByIds(ids: K[]): Promise<KeyValueTuple<string, V>[]>;
-    getByIdsAsBuffer(ids: K[]): Promise<KeyValueTuple<K, Buffer>[]>;
+    getByIdsRaw(ids: K[]): Promise<KeyValueTuple<K, RAW_V>[]>;
     save(id: K, value: V, opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
-    saveAsBuffer(id: K, value: Buffer, opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
+    saveRaw(id: K, value: RAW_V, opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
     saveBatch(entries: KeyValueTuple<K, V>[], opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
-    saveBatchAsBuffer(entries: KeyValueDBTuple[], opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
+    saveBatchRaw(entries: KeyValueTuple<K, RAW_V>[], opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
     deleteByIds(ids: K[]): Promise<void>;
     deleteById(id: K): Promise<void>;
     streamIds(limit?: number): ReadableTyped<K>;
@@ -72,4 +63,5 @@ export declare class CommonKeyValueDao<V, K extends string = string> {
      * Returns the new value of the field.
      */
     increment(id: K, by?: number): Promise<number>;
+    incrementBatch(entries: IncrementTuple[]): Promise<IncrementTuple[]>;
 }