@naturalcycles/db-lib 9.22.0 → 9.23.0

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

@@ -1,7 +1,7 @@
 import { 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, KeyValueDBTuple } from '../../kv/commonKeyValueDB';
 export interface InMemoryKeyValueDBCfg {
 }
 export declare class InMemoryKeyValueDB implements CommonKeyValueDB {
@@ -11,7 +11,7 @@ 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>;
@@ -21,6 +21,5 @@ export declare class InMemoryKeyValueDB implements CommonKeyValueDB {
     streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
     streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
     count(table: string): Promise<number>;
-    increment(table: string, id: string, by?: number): Promise<number>;
-    incrementBatch(table: string, incrementMap: StringMap<number>): Promise<StringMap<number>>;
+    incrementBatch(table: string, entries: IncrementTuple[]): Promise<IncrementTuple[]>;
 }

package/dist/adapter/inmemory/inMemoryKeyValueDB.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryKeyValueDB = void 0;
 const node_stream_1 = require("node:stream");
-const js_lib_1 = require("@naturalcycles/js-lib");
 const commonKeyValueDB_1 = require("../../kv/commonKeyValueDB");
 class InMemoryKeyValueDB {
     constructor(cfg = {}) {
@@ -10,7 +9,7 @@ class InMemoryKeyValueDB {
         this.support = {
             ...commonKeyValueDB_1.commonKeyValueDBFullSupport,
         };
-        // data[table][id] > Buffer
+        // data[table][id] => any (can be Buffer, or number)
         this.data = {};
     }
     async ping() { }
@@ -19,14 +18,13 @@ class InMemoryKeyValueDB {
         this.data[table] ||= {};
         ids.forEach(id => delete this.data[table][id]);
     }
-    // todo: but should we work with Tuples or Objects?
     async getByIds(table, ids) {
         this.data[table] ||= {};
         return ids.map(id => [id, this.data[table][id]]).filter(e => e[1]);
     }
     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));
@@ -41,23 +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;
-    }
-    async incrementBatch(table, incrementMap) {
-        this.data[table] ||= {};
-        const result = {};
-        for (const [id, by] of (0, js_lib_1._stringMapEntries)(incrementMap)) {
-            const newValue = parseInt(this.data[table][id]?.toString() || '0') + by;
-            // todo: but should this.data store Buffer or number for incremented values?
-            this.data[table][id] = Buffer.from(String(newValue));
-            result[id] = newValue;
-        }
-        return result;
+        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/kv/commonKeyValueDB.d.ts

@@ -1,4 +1,4 @@
-import { StringMap, UnixTimestampNumber } from '@naturalcycles/js-lib';
+import { Integer, UnixTimestampNumber } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBCreateOptions } from '../db.model';
 /**
@@ -32,30 +32,25 @@ export interface CommonKeyValueDB {
     streamValues: (table: string, limit?: number) => ReadableTyped<Buffer>;
     streamEntries: (table: string, limit?: number) => ReadableTyped<KeyValueDBTuple>;
     count: (table: string) => Promise<number>;
-    /**
-     * Increments the value of a key in a table by a given amount.
-     * Default increment is 1 when `by` is not provided.
-     *
-     * Returns the new value.
-     *
-     * @experimental
-     */
-    increment: (table: string, id: string, by?: number) => Promise<number>;
     /**
      * Perform a batch of Increment operations.
-     * Given incrementMap, increment each key of it by the given amount (value of the map).
+     * Given entries array, increment each key of it (1st index of the tuple) by the given amount (2nd index of the tuple).
      *
      * Example:
-     * { key1: 2, key2: 3 }
+     * [
+     *   ['key1', 2],
+     *   ['key2', 3],
+     * ]
      * would increment `key1` by 2, and `key2` by 3.
      *
-     * Returns the incrementMap with the same keys and updated values.
+     * Returns the entries array with tuples of the same structure, with updated numbers.
      *
      * @experimental
      */
-    incrementBatch: (table: string, incrementMap: StringMap<number>) => Promise<StringMap<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,7 +2,7 @@ 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';
+import { CommonKeyValueDB, CommonKeyValueDBSaveBatchOptions, IncrementTuple, KeyValueDBTuple } from './commonKeyValueDB';
 export interface CommonKeyValueDaoCfg<V> {
     db: CommonKeyValueDB;
     table: string;
@@ -23,40 +23,29 @@ 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>;
 }
 export type CommonKeyValueDaoSaveOptions = CommonKeyValueDBSaveBatchOptions;
-export declare class CommonKeyValueDao<V, K extends string = string> {
+export interface CommonKeyValueDaoTransformer<V> {
+    valueToBuffer: (v: V) => Promise<Buffer>;
+    bufferToValue: (buf: Buffer) => Promise<V>;
+}
+export declare const commonKeyValueDaoDeflatedJsonTransformer: CommonKeyValueDaoTransformer<any>;
+export declare class CommonKeyValueDao<K extends string = string, V = Buffer> {
     constructor(cfg: CommonKeyValueDaoCfg<V>);
     cfg: CommonKeyValueDaoCfg<V> & {
-        hooks: NonNullable<CommonKeyValueDaoCfg<V>['hooks']>;
         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>;
     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>;
     getByIds(ids: K[]): Promise<KeyValueTuple<string, V>[]>;
-    getByIdsAsBuffer(ids: K[]): Promise<KeyValueTuple<K, Buffer>[]>;
+    getByIdsAsBuffer(ids: K[]): Promise<KeyValueDBTuple[]>;
     save(id: K, value: V, opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
-    saveAsBuffer(id: K, value: Buffer, opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
     saveBatch(entries: KeyValueTuple<K, V>[], opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
-    saveBatchAsBuffer(entries: KeyValueDBTuple[], opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
     deleteByIds(ids: K[]): Promise<void>;
     deleteById(id: K): Promise<void>;
     streamIds(limit?: number): ReadableTyped<K>;
@@ -72,4 +61,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[]>;
 }

package/dist/kv/commonKeyValueDao.js

@@ -1,24 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommonKeyValueDao = void 0;
+exports.CommonKeyValueDao = exports.commonKeyValueDaoDeflatedJsonTransformer = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
+exports.commonKeyValueDaoDeflatedJsonTransformer = {
+    valueToBuffer: async (v) => await (0, nodejs_lib_1.deflateString)(JSON.stringify(v)),
+    bufferToValue: async (buf) => JSON.parse(await (0, nodejs_lib_1.inflateToString)(buf)),
+};
 // todo: logging
 // todo: readonly
 class CommonKeyValueDao {
     constructor(cfg) {
         this.cfg = {
-            hooks: {},
             logger: console,
             ...cfg,
         };
-        if (cfg.deflatedJsonValue) {
-            this.cfg.hooks = {
-                mapValueToBuffer: async (v) => await (0, nodejs_lib_1.deflateString)(JSON.stringify(v)),
-                mapBufferToValue: async (buf) => JSON.parse(await (0, nodejs_lib_1.inflateToString)(buf)),
-                ...cfg.hooks,
-            };
-        }
     }
     async ping() {
         await this.cfg.db.ping();
@@ -26,11 +22,6 @@ class CommonKeyValueDao {
     async createTable(opt = {}) {
         await this.cfg.db.createTable(this.cfg.table, opt);
     }
-    create(input = {}) {
-        return {
-            ...this.cfg.hooks.beforeCreate?.(input),
-        };
-    }
     async getById(id) {
         if (!id)
             return null;
@@ -65,54 +56,31 @@ class CommonKeyValueDao {
         }
         return r[1];
     }
-    async getByIdOrEmpty(id, part = {}) {
-        const [r] = await this.getByIds([id]);
-        if (r)
-            return r[1];
-        return {
-            ...this.cfg.hooks.beforeCreate?.({}),
-            ...part,
-        };
-    }
-    async patch(id, patch, opt) {
-        const v = {
-            ...(await this.getByIdOrEmpty(id)),
-            ...patch,
-        };
-        await this.save(id, v, opt);
-        return v;
-    }
     async getByIds(ids) {
         const entries = await this.cfg.db.getByIds(this.cfg.table, ids);
-        if (!this.cfg.hooks.mapBufferToValue)
+        if (!this.cfg.transformer)
             return entries;
-        return await (0, js_lib_1.pMap)(entries, async ([id, buf]) => [
+        return await (0, js_lib_1.pMap)(entries, async ([id, raw]) => [
             id,
-            await this.cfg.hooks.mapBufferToValue(buf),
+            await this.cfg.transformer.bufferToValue(raw),
         ]);
     }
     async getByIdsAsBuffer(ids) {
-        return (await this.cfg.db.getByIds(this.cfg.table, ids));
+        return await this.cfg.db.getByIds(this.cfg.table, ids);
     }
     async save(id, value, opt) {
         await this.saveBatch([[id, value]], opt);
     }
-    async saveAsBuffer(id, value, opt) {
-        await this.cfg.db.saveBatch(this.cfg.table, [[id, value]], opt);
-    }
     async saveBatch(entries, opt) {
-        const { mapValueToBuffer } = this.cfg.hooks;
-        let bufferEntries;
-        if (!mapValueToBuffer) {
-            bufferEntries = entries;
+        const { transformer } = this.cfg;
+        let rawEntries;
+        if (!transformer) {
+            rawEntries = entries;
         }
         else {
-            bufferEntries = await (0, js_lib_1.pMap)(entries, async ([id, v]) => [id, await mapValueToBuffer(v)]);
+            rawEntries = await (0, js_lib_1.pMap)(entries, async ([id, v]) => [id, await transformer.valueToBuffer(v)]);
         }
-        await this.cfg.db.saveBatch(this.cfg.table, bufferEntries, opt);
-    }
-    async saveBatchAsBuffer(entries, opt) {
-        await this.cfg.db.saveBatch(this.cfg.table, entries, opt);
+        await this.cfg.db.saveBatch(this.cfg.table, rawEntries, opt);
     }
     async deleteByIds(ids) {
         await this.cfg.db.deleteByIds(this.cfg.table, ids);
@@ -124,13 +92,13 @@ class CommonKeyValueDao {
         return this.cfg.db.streamIds(this.cfg.table, limit);
     }
     streamValues(limit) {
-        const { mapBufferToValue } = this.cfg.hooks;
-        if (!mapBufferToValue) {
+        const { transformer } = this.cfg;
+        if (!transformer) {
             return this.cfg.db.streamValues(this.cfg.table, limit);
         }
         return this.cfg.db.streamValues(this.cfg.table, limit).flatMap(async (buf) => {
             try {
-                return [await mapBufferToValue(buf)];
+                return [await transformer.bufferToValue(buf)];
             }
             catch (err) {
                 this.cfg.logger.error(err);
@@ -141,13 +109,13 @@ class CommonKeyValueDao {
         });
     }
     streamEntries(limit) {
-        const { mapBufferToValue } = this.cfg.hooks;
-        if (!mapBufferToValue) {
+        const { transformer } = this.cfg;
+        if (!transformer) {
             return this.cfg.db.streamEntries(this.cfg.table, limit);
         }
         return this.cfg.db.streamEntries(this.cfg.table, limit).flatMap(async ([id, buf]) => {
             try {
-                return [[id, await mapBufferToValue(buf)]];
+                return [[id, await transformer.bufferToValue(buf)]];
             }
             catch (err) {
                 this.cfg.logger.error(err);
@@ -173,7 +141,11 @@ class CommonKeyValueDao {
      * Returns the new value of the field.
      */
     async increment(id, by = 1) {
-        return await this.cfg.db.increment(this.cfg.table, id, by);
+        const [t] = await this.cfg.db.incrementBatch(this.cfg.table, [[id, by]]);
+        return t[1];
+    }
+    async incrementBatch(entries) {
+        return await this.cfg.db.incrementBatch(this.cfg.table, entries);
     }
 }
 exports.CommonKeyValueDao = CommonKeyValueDao;

package/dist/kv/commonKeyValueDaoMemoCache.d.ts

@@ -1,7 +1,7 @@
 import { AsyncMemoCache, MISS, NumberOfSeconds } from '@naturalcycles/js-lib';
 import { CommonKeyValueDao } from './commonKeyValueDao';
 export interface CommonKeyValueDaoMemoCacheCfg<VALUE> {
-    dao: CommonKeyValueDao<VALUE>;
+    dao: CommonKeyValueDao<string, VALUE>;
     /**
      * If set, every `set()` will set `expireAt` (TTL) option.
      */
@@ -15,7 +15,7 @@ export interface CommonKeyValueDaoMemoCacheCfg<VALUE> {
  * Also, does not support .clear(), as it's more dangerous than useful to actually
  * clear the whole table/cache.
  */
-export declare class CommonKeyValueDaoMemoCache<VALUE = any> implements AsyncMemoCache<string, VALUE> {
+export declare class CommonKeyValueDaoMemoCache<VALUE> implements AsyncMemoCache<string, VALUE> {
     private cfg;
     constructor(cfg: CommonKeyValueDaoMemoCacheCfg<VALUE>);
     get(k: string): Promise<VALUE | typeof MISS>;

package/dist/testing/keyValueDBTest.js

@@ -4,7 +4,10 @@ exports.runCommonKeyValueDBTest = runCommonKeyValueDBTest;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const test_model_1 = require("./test.model");
 const testIds = (0, js_lib_1._range)(1, 4).map(n => `id${n}`);
-const testEntries = testIds.map(id => [id, Buffer.from(`${id}value`)]);
+const testEntries = testIds.map(id => [
+    id,
+    Buffer.from(`${id}value`),
+]);
 function runCommonKeyValueDBTest(db) {
     beforeAll(async () => {
         // Tests in this suite are not isolated,
@@ -89,23 +92,23 @@ function runCommonKeyValueDBTest(db) {
         const id = 'nonExistingField';
         const id2 = 'nonExistingField2';
         test('increment on a non-existing field should set the value to 1', async () => {
-            const result = await db.increment(test_model_1.TEST_TABLE, id);
-            expect(result).toBe(1);
+            const result = await db.incrementBatch(test_model_1.TEST_TABLE, [[id, 1]]);
+            expect(result).toEqual([[id, 1]]);
         });
         test('increment on a existing field should increase the value by one', async () => {
-            const result = await db.increment(test_model_1.TEST_TABLE, id);
-            expect(result).toBe(2);
+            const result = await db.incrementBatch(test_model_1.TEST_TABLE, [[id, 1]]);
+            expect(result).toEqual([[id, 2]]);
         });
         test('increment should increase the value by the specified amount', async () => {
-            const result = await db.increment(test_model_1.TEST_TABLE, id, 2);
-            expect(result).toBe(4);
+            const result = await db.incrementBatch(test_model_1.TEST_TABLE, [[id, 2]]);
+            expect(result).toEqual([[id, 4]]);
         });
         test('increment 2 ids at the same time', async () => {
-            const result = await db.incrementBatch(test_model_1.TEST_TABLE, {
-                [id]: 1,
-                [id2]: 2,
-            });
-            expect(result).toEqual({
+            const result = await db.incrementBatch(test_model_1.TEST_TABLE, [
+                [id, 1],
+                [id2, 2],
+            ]);
+            expect(Object.fromEntries(result)).toEqual({
                 [id]: 5,
                 [id2]: 2,
             });

package/dist/testing/keyValueDaoTest.d.ts

@@ -1,2 +1,2 @@
-import { CommonKeyValueDao } from '../kv/commonKeyValueDao';
-export declare function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void;
+import { CommonKeyValueDB } from '../kv/commonKeyValueDB';
+export declare function runCommonKeyValueDaoTest(db: CommonKeyValueDB): void;

package/dist/testing/keyValueDaoTest.js

@@ -2,9 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommonKeyValueDaoTest = runCommonKeyValueDaoTest;
 const js_lib_1 = require("@naturalcycles/js-lib");
-const testIds = (0, js_lib_1._range)(1, 4).map(n => `id${n}`);
-const testEntries = testIds.map(id => [id, Buffer.from(`${id}value`)]);
-function runCommonKeyValueDaoTest(dao) {
+const commonKeyValueDao_1 = require("../kv/commonKeyValueDao");
+const test_model_1 = require("./test.model");
+const testItems = (0, test_model_1.createTestItemsBM)(4);
+const testIds = testItems.map(e => e.id);
+const testEntries = testItems.map(e => [e.id, e]);
+function runCommonKeyValueDaoTest(db) {
+    const dao = new commonKeyValueDao_1.CommonKeyValueDao({
+        db,
+        table: test_model_1.TEST_TABLE,
+        // todo: make this test support "deflatedJson" transformer
+    });
+    const { support } = db;
     beforeAll(async () => {
         // Tests in this suite are not isolated,
         // and failing tests can leave the DB in an unexpected state for other tests,
@@ -17,7 +26,6 @@ function runCommonKeyValueDaoTest(dao) {
         const ids = await dao.streamIds().toArray();
         await dao.deleteByIds(ids);
     });
-    const { support } = dao.cfg.db;
     test('ping', async () => {
         await dao.ping();
     });
@@ -34,8 +42,11 @@ function runCommonKeyValueDaoTest(dao) {
     test('saveBatch, then getByIds', async () => {
         await dao.saveBatch(testEntries);
         const entries = await dao.getByIds(testIds);
+        // console.log(typeof entries[0]![1], entries[0]![1])
         (0, js_lib_1._sortBy)(entries, e => e[0], true);
-        expect(entries).toEqual(testEntries);
+        expect(entries).toEqual(testEntries); // Jest doesn't allow to compare Buffers directly
+        // expect(entries.map(e => e[0])).toEqual(testEntries.map(e => e[0]))
+        // expect(entries.map(e => e[1].toString())).toEqual(testEntries.map(e => e[1].toString()))
     });
     test('streamIds', async () => {
         const ids = await dao.streamIds().toArray();
@@ -77,17 +88,29 @@ function runCommonKeyValueDaoTest(dao) {
         expect(results).toEqual([]);
     });
     if (support.increment) {
+        const id = 'nonExistingField';
+        const id2 = 'nonExistingField2';
         test('increment on a non-existing field should set the value to 1', async () => {
-            const result = await dao.increment('nonExistingField');
+            const result = await dao.increment(id);
             expect(result).toBe(1);
         });
         test('increment on a existing field should increase the value by one', async () => {
-            const result = await dao.increment('nonExistingField');
+            const result = await dao.increment(id);
             expect(result).toBe(2);
         });
         test('increment should increase the value by the specified amount', async () => {
-            const result = await dao.increment('nonExistingField', 2);
+            const result = await dao.increment(id, 2);
             expect(result).toBe(4);
         });
+        test('increment 2 ids at the same time', async () => {
+            const result = await dao.incrementBatch([
+                [id, 1],
+                [id2, 2],
+            ]);
+            expect(Object.fromEntries(result)).toEqual({
+                [id]: 5,
+                [id2]: 2,
+            });
+        });
     }
 }

package/package.json

@@ -45,7 +45,7 @@
   "engines": {
     "node": ">=20.13"
   },
-  "version": "9.22.0",
+  "version": "9.23.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/adapter/inmemory/inMemoryKeyValueDB.ts

@@ -1,10 +1,11 @@
 import { Readable } from 'node:stream'
-import { _stringMapEntries, StringMap } from '@naturalcycles/js-lib'
+import { StringMap } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDBCreateOptions } from '../../db.model'
 import {
   CommonKeyValueDB,
   commonKeyValueDBFullSupport,
+  IncrementTuple,
   KeyValueDBTuple,
 } from '../../kv/commonKeyValueDB'
 
@@ -17,8 +18,8 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
     ...commonKeyValueDBFullSupport,
   }
 
-  // data[table][id] > Buffer
-  data: StringMap<StringMap<Buffer>> = {}
+  // data[table][id] => any (can be Buffer, or number)
+  data: StringMap<StringMap<any>> = {}
 
   async ping(): Promise<void> {}
 
@@ -29,7 +30,6 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
     ids.forEach(id => delete this.data[table]![id])
   }
 
-  // todo: but should we work with Tuples or Objects?
   async getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]> {
     this.data[table] ||= {}
     return ids.map(id => [id, this.data[table]![id]!] as KeyValueDBTuple).filter(e => e[1])
@@ -37,7 +37,7 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
 
   async saveBatch(table: string, entries: KeyValueDBTuple[]): Promise<void> {
     this.data[table] ||= {}
-    entries.forEach(([id, buf]) => (this.data[table]![id] = buf))
+    entries.forEach(([id, v]) => (this.data[table]![id] = v))
   }
 
   streamIds(table: string, limit?: number): ReadableTyped<string> {
@@ -57,28 +57,13 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
     return Object.keys(this.data[table]).length
   }
 
-  async increment(table: string, id: string, by = 1): Promise<number> {
+  async incrementBatch(table: string, entries: IncrementTuple[]): Promise<IncrementTuple[]> {
     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
-  }
-
-  async incrementBatch(table: string, incrementMap: StringMap<number>): Promise<StringMap<number>> {
-    this.data[table] ||= {}
-
-    const result: StringMap<number> = {}
-
-    for (const [id, by] of _stringMapEntries(incrementMap)) {
-      const newValue = parseInt(this.data[table][id]?.toString() || '0') + by
-      // todo: but should this.data store Buffer or number for incremented values?
-      this.data[table][id] = Buffer.from(String(newValue))
-      result[id] = newValue
-    }
-
-    return result
+    return entries.map(([id, by]) => {
+      const newValue = ((this.data[table]![id] as number | undefined) || 0) + by
+      this.data[table]![id] = newValue
+      return [id, newValue]
+    })
   }
 }

package/src/kv/commonKeyValueDB.ts

@@ -1,4 +1,4 @@
-import { StringMap, UnixTimestampNumber } from '@naturalcycles/js-lib'
+import { Integer, UnixTimestampNumber } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDBCreateOptions } from '../db.model'
 
@@ -45,33 +45,28 @@ export interface CommonKeyValueDB {
 
   count: (table: string) => Promise<number>
 
-  /**
-   * Increments the value of a key in a table by a given amount.
-   * Default increment is 1 when `by` is not provided.
-   *
-   * Returns the new value.
-   *
-   * @experimental
-   */
-  increment: (table: string, id: string, by?: number) => Promise<number>
-
   /**
    * Perform a batch of Increment operations.
-   * Given incrementMap, increment each key of it by the given amount (value of the map).
+   * Given entries array, increment each key of it (1st index of the tuple) by the given amount (2nd index of the tuple).
    *
    * Example:
-   * { key1: 2, key2: 3 }
+   * [
+   *   ['key1', 2],
+   *   ['key2', 3],
+   * ]
    * would increment `key1` by 2, and `key2` by 3.
    *
-   * Returns the incrementMap with the same keys and updated values.
+   * Returns the entries array with tuples of the same structure, with updated numbers.
    *
    * @experimental
    */
-  incrementBatch: (table: string, incrementMap: StringMap<number>) => Promise<StringMap<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/src/kv/commonKeyValueDao.ts

@@ -5,6 +5,7 @@ import { CommonDBCreateOptions } from '../db.model'
 import {
   CommonKeyValueDB,
   CommonKeyValueDBSaveBatchOptions,
+  IncrementTuple,
   KeyValueDBTuple,
 } from './commonKeyValueDB'
 
@@ -34,44 +35,33 @@ export interface CommonKeyValueDaoCfg<V> {
    */
   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>
 }
 
 export type CommonKeyValueDaoSaveOptions = CommonKeyValueDBSaveBatchOptions
 
+export interface CommonKeyValueDaoTransformer<V> {
+  valueToBuffer: (v: V) => Promise<Buffer>
+  bufferToValue: (buf: Buffer) => Promise<V>
+}
+
+export const commonKeyValueDaoDeflatedJsonTransformer: CommonKeyValueDaoTransformer<any> = {
+  valueToBuffer: async v => await deflateString(JSON.stringify(v)),
+  bufferToValue: async buf => JSON.parse(await inflateToString(buf)),
+}
+
 // todo: logging
 // todo: readonly
 
-export class CommonKeyValueDao<V, K extends string = string> {
+export class CommonKeyValueDao<K extends string = string, V = Buffer> {
   constructor(cfg: CommonKeyValueDaoCfg<V>) {
     this.cfg = {
-      hooks: {},
       logger: console,
       ...cfg,
     }
-
-    if (cfg.deflatedJsonValue) {
-      this.cfg.hooks = {
-        mapValueToBuffer: async v => await deflateString(JSON.stringify(v)),
-        mapBufferToValue: async buf => JSON.parse(await inflateToString(buf)),
-        ...cfg.hooks,
-      }
-    }
   }
 
   cfg: CommonKeyValueDaoCfg<V> & {
-    hooks: NonNullable<CommonKeyValueDaoCfg<V>['hooks']>
     logger: CommonLogger
   }
 
@@ -83,12 +73,6 @@ export class CommonKeyValueDao<V, K extends string = string> {
     await this.cfg.db.createTable(this.cfg.table, opt)
   }
 
-  create(input: Partial<V> = {}): V {
-    return {
-      ...this.cfg.hooks.beforeCreate?.(input),
-    } as V
-  }
-
   async getById(id?: K): Promise<V | null> {
     if (!id) return null
     const [r] = await this.getByIds([id])
@@ -129,70 +113,38 @@ export class CommonKeyValueDao<V, K extends string = string> {
     return r[1]
   }
 
-  async getByIdOrEmpty(id: K, part: Partial<V> = {}): Promise<V> {
-    const [r] = await this.getByIds([id])
-    if (r) return r[1]
-
-    return {
-      ...this.cfg.hooks.beforeCreate?.({}),
-      ...part,
-    } as V
-  }
-
-  async patch(id: K, patch: Partial<V>, opt?: CommonKeyValueDaoSaveOptions): Promise<V> {
-    const v: V = {
-      ...(await this.getByIdOrEmpty(id)),
-      ...patch,
-    }
-
-    await this.save(id, v, opt)
-
-    return v
-  }
-
   async getByIds(ids: K[]): Promise<KeyValueTuple<string, V>[]> {
     const entries = await this.cfg.db.getByIds(this.cfg.table, ids)
-    if (!this.cfg.hooks.mapBufferToValue) return entries as any
+    if (!this.cfg.transformer) return entries as any
 
-    return await pMap(entries, async ([id, buf]) => [
+    return await pMap(entries, async ([id, raw]) => [
       id,
-      await this.cfg.hooks.mapBufferToValue!(buf),
+      await this.cfg.transformer!.bufferToValue(raw),
     ])
   }
 
-  async getByIdsAsBuffer(ids: K[]): Promise<KeyValueTuple<K, Buffer>[]> {
-    return (await this.cfg.db.getByIds(this.cfg.table, ids)) as KeyValueTuple<K, Buffer>[]
+  async getByIdsAsBuffer(ids: K[]): Promise<KeyValueDBTuple[]> {
+    return await this.cfg.db.getByIds(this.cfg.table, ids)
   }
 
   async save(id: K, value: V, opt?: CommonKeyValueDaoSaveOptions): Promise<void> {
     await this.saveBatch([[id, value]], opt)
   }
 
-  async saveAsBuffer(id: K, value: Buffer, opt?: CommonKeyValueDaoSaveOptions): Promise<void> {
-    await this.cfg.db.saveBatch(this.cfg.table, [[id, value]], opt)
-  }
-
   async saveBatch(
     entries: KeyValueTuple<K, V>[],
     opt?: CommonKeyValueDaoSaveOptions,
   ): Promise<void> {
-    const { mapValueToBuffer } = this.cfg.hooks
-    let bufferEntries: KeyValueDBTuple[]
+    const { transformer } = this.cfg
+    let rawEntries: KeyValueDBTuple[]
 
-    if (!mapValueToBuffer) {
-      bufferEntries = entries as any
+    if (!transformer) {
+      rawEntries = entries as any
     } else {
-      bufferEntries = await pMap(entries, async ([id, v]) => [id, await mapValueToBuffer(v)])
+      rawEntries = await pMap(entries, async ([id, v]) => [id, await transformer.valueToBuffer(v)])
     }
 
-    await this.cfg.db.saveBatch(this.cfg.table, bufferEntries, opt)
-  }
-
-  async saveBatchAsBuffer(
-    entries: KeyValueDBTuple[],
-    opt?: CommonKeyValueDaoSaveOptions,
-  ): Promise<void> {
-    await this.cfg.db.saveBatch(this.cfg.table, entries, opt)
+    await this.cfg.db.saveBatch(this.cfg.table, rawEntries, opt)
   }
 
   async deleteByIds(ids: K[]): Promise<void> {
@@ -208,16 +160,16 @@ export class CommonKeyValueDao<V, K extends string = string> {
   }
 
   streamValues(limit?: number): ReadableTyped<V> {
-    const { mapBufferToValue } = this.cfg.hooks
+    const { transformer } = this.cfg
 
-    if (!mapBufferToValue) {
+    if (!transformer) {
       return this.cfg.db.streamValues(this.cfg.table, limit) as ReadableTyped<V>
     }
 
     return this.cfg.db.streamValues(this.cfg.table, limit).flatMap(
       async buf => {
         try {
-          return [await mapBufferToValue(buf)]
+          return [await transformer.bufferToValue(buf)]
         } catch (err) {
           this.cfg.logger.error(err)
           return [] // SKIP
@@ -230,18 +182,16 @@ export class CommonKeyValueDao<V, K extends string = string> {
   }
 
   streamEntries(limit?: number): ReadableTyped<KeyValueTuple<K, V>> {
-    const { mapBufferToValue } = this.cfg.hooks
+    const { transformer } = this.cfg
 
-    if (!mapBufferToValue) {
+    if (!transformer) {
       return this.cfg.db.streamEntries(this.cfg.table, limit) as ReadableTyped<KeyValueTuple<K, V>>
     }
 
-    return (
-      this.cfg.db.streamEntries(this.cfg.table, limit) as ReadableTyped<KeyValueTuple<K, Buffer>>
-    ).flatMap(
+    return this.cfg.db.streamEntries(this.cfg.table, limit).flatMap(
       async ([id, buf]) => {
         try {
-          return [[id, await mapBufferToValue(buf)]]
+          return [[id as K, await transformer.bufferToValue(buf)]]
         } catch (err) {
           this.cfg.logger.error(err)
           return [] // SKIP
@@ -272,6 +222,11 @@ export class CommonKeyValueDao<V, K extends string = string> {
    * Returns the new value of the field.
    */
   async increment(id: K, by = 1): Promise<number> {
-    return await this.cfg.db.increment(this.cfg.table, id, by)
+    const [t] = await this.cfg.db.incrementBatch(this.cfg.table, [[id, by]])
+    return t![1]
+  }
+
+  async incrementBatch(entries: IncrementTuple[]): Promise<IncrementTuple[]> {
+    return await this.cfg.db.incrementBatch(this.cfg.table, entries)
   }
 }

package/src/kv/commonKeyValueDaoMemoCache.ts

@@ -2,7 +2,7 @@ import { AsyncMemoCache, localTime, MISS, NumberOfSeconds } from '@naturalcycles
 import { CommonKeyValueDao } from './commonKeyValueDao'
 
 export interface CommonKeyValueDaoMemoCacheCfg<VALUE> {
-  dao: CommonKeyValueDao<VALUE>
+  dao: CommonKeyValueDao<string, VALUE>
 
   /**
    * If set, every `set()` will set `expireAt` (TTL) option.
@@ -18,7 +18,7 @@ export interface CommonKeyValueDaoMemoCacheCfg<VALUE> {
  * Also, does not support .clear(), as it's more dangerous than useful to actually
  * clear the whole table/cache.
  */
-export class CommonKeyValueDaoMemoCache<VALUE = any> implements AsyncMemoCache<string, VALUE> {
+export class CommonKeyValueDaoMemoCache<VALUE> implements AsyncMemoCache<string, VALUE> {
   constructor(private cfg: CommonKeyValueDaoMemoCacheCfg<VALUE>) {}
 
   async get(k: string): Promise<VALUE | typeof MISS> {

package/src/testing/keyValueDBTest.ts

@@ -1,10 +1,13 @@
-import { _range, _sortBy } from '@naturalcycles/js-lib'
-import { CommonKeyValueDB, KeyValueDBTuple } from '../kv/commonKeyValueDB'
+import { _range, _sortBy, KeyValueTuple } from '@naturalcycles/js-lib'
+import { CommonKeyValueDB } from '../kv/commonKeyValueDB'
 import { TEST_TABLE } from './test.model'
 
 const testIds = _range(1, 4).map(n => `id${n}`)
 
-const testEntries: KeyValueDBTuple[] = testIds.map(id => [id, Buffer.from(`${id}value`)])
+const testEntries: KeyValueTuple<string, Buffer>[] = testIds.map(id => [
+  id,
+  Buffer.from(`${id}value`),
+])
 
 export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
   beforeAll(async () => {
@@ -109,26 +112,26 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
     const id2 = 'nonExistingField2'
 
     test('increment on a non-existing field should set the value to 1', async () => {
-      const result = await db.increment(TEST_TABLE, id)
-      expect(result).toBe(1)
+      const result = await db.incrementBatch(TEST_TABLE, [[id, 1]])
+      expect(result).toEqual([[id, 1]])
     })
 
     test('increment on a existing field should increase the value by one', async () => {
-      const result = await db.increment(TEST_TABLE, id)
-      expect(result).toBe(2)
+      const result = await db.incrementBatch(TEST_TABLE, [[id, 1]])
+      expect(result).toEqual([[id, 2]])
     })
 
     test('increment should increase the value by the specified amount', async () => {
-      const result = await db.increment(TEST_TABLE, id, 2)
-      expect(result).toBe(4)
+      const result = await db.incrementBatch(TEST_TABLE, [[id, 2]])
+      expect(result).toEqual([[id, 4]])
     })
 
     test('increment 2 ids at the same time', async () => {
-      const result = await db.incrementBatch(TEST_TABLE, {
-        [id]: 1,
-        [id2]: 2,
-      })
-      expect(result).toEqual({
+      const result = await db.incrementBatch(TEST_TABLE, [
+        [id, 1],
+        [id2, 2],
+      ])
+      expect(Object.fromEntries(result)).toEqual({
         [id]: 5,
         [id2]: 2,
       })

package/src/testing/keyValueDaoTest.ts

@@ -1,11 +1,20 @@
-import { _range, _sortBy } from '@naturalcycles/js-lib'
+import { _sortBy, KeyValueTuple } from '@naturalcycles/js-lib'
 import { CommonKeyValueDao } from '../kv/commonKeyValueDao'
-import { KeyValueDBTuple } from '../kv/commonKeyValueDB'
-
-const testIds = _range(1, 4).map(n => `id${n}`)
-const testEntries: KeyValueDBTuple[] = testIds.map(id => [id, Buffer.from(`${id}value`)])
+import { CommonKeyValueDB } from '../kv/commonKeyValueDB'
+import { createTestItemsBM, TEST_TABLE, TestItemBM } from './test.model'
+
+const testItems = createTestItemsBM(4)
+const testIds = testItems.map(e => e.id)
+const testEntries: KeyValueTuple<string, TestItemBM>[] = testItems.map(e => [e.id, e])
+
+export function runCommonKeyValueDaoTest(db: CommonKeyValueDB): void {
+  const dao = new CommonKeyValueDao<string, TestItemBM>({
+    db,
+    table: TEST_TABLE,
+    // todo: make this test support "deflatedJson" transformer
+  })
+  const { support } = db
 
-export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
   beforeAll(async () => {
     // Tests in this suite are not isolated,
     // and failing tests can leave the DB in an unexpected state for other tests,
@@ -20,8 +29,6 @@ export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
     await dao.deleteByIds(ids)
   })
 
-  const { support } = dao.cfg.db
-
   test('ping', async () => {
     await dao.ping()
   })
@@ -43,8 +50,12 @@ export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
     await dao.saveBatch(testEntries)
 
     const entries = await dao.getByIds(testIds)
+    // console.log(typeof entries[0]![1], entries[0]![1])
+
     _sortBy(entries, e => e[0], true)
-    expect(entries).toEqual(testEntries)
+    expect(entries).toEqual(testEntries) // Jest doesn't allow to compare Buffers directly
+    // expect(entries.map(e => e[0])).toEqual(testEntries.map(e => e[0]))
+    // expect(entries.map(e => e[1].toString())).toEqual(testEntries.map(e => e[1].toString()))
   })
 
   test('streamIds', async () => {
@@ -94,19 +105,33 @@ export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
   })
 
   if (support.increment) {
+    const id = 'nonExistingField'
+    const id2 = 'nonExistingField2'
+
     test('increment on a non-existing field should set the value to 1', async () => {
-      const result = await dao.increment('nonExistingField')
+      const result = await dao.increment(id)
       expect(result).toBe(1)
     })
 
     test('increment on a existing field should increase the value by one', async () => {
-      const result = await dao.increment('nonExistingField')
+      const result = await dao.increment(id)
       expect(result).toBe(2)
     })
 
     test('increment should increase the value by the specified amount', async () => {
-      const result = await dao.increment('nonExistingField', 2)
+      const result = await dao.increment(id, 2)
       expect(result).toBe(4)
     })
+
+    test('increment 2 ids at the same time', async () => {
+      const result = await dao.incrementBatch([
+        [id, 1],
+        [id2, 2],
+      ])
+      expect(Object.fromEntries(result)).toEqual({
+        [id]: 5,
+        [id2]: 2,
+      })
+    })
   }
 }