@naturalcycles/db-lib 9.22.0 → 9.22.1

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,16 +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, 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] => V
         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, KeyValueTuple, UnixTimestampNumber } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBCreateOptions } from '../db.model';
 /**
@@ -25,37 +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>;
-    /**
-     * 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,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[]>;
 }

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 = {
+    valueToRaw: async (v) => await (0, nodejs_lib_1.deflateString)(JSON.stringify(v)),
+    rawToValue: async (raw) => JSON.parse(await (0, nodejs_lib_1.inflateToString)(raw)),
+};
 // 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,18 +22,13 @@ 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;
         const [r] = await this.getByIds([id]);
         return r?.[1] || null;
     }
-    async getByIdAsBuffer(id) {
+    async getByIdRaw(id) {
         if (!id)
             return null;
         const [r] = await this.cfg.db.getByIds(this.cfg.table, [id]);
@@ -54,7 +45,7 @@ class CommonKeyValueDao {
         }
         return r[1];
     }
-    async requireByIdAsBuffer(id) {
+    async requireByIdRaw(id) {
         const [r] = await this.cfg.db.getByIds(this.cfg.table, [id]);
         if (!r) {
             const { table } = this.cfg;
@@ -65,53 +56,36 @@ 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.rawToValue(raw),
         ]);
     }
-    async getByIdsAsBuffer(ids) {
+    async getByIdsRaw(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) {
+    async saveRaw(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.valueToRaw(v)]);
         }
-        await this.cfg.db.saveBatch(this.cfg.table, bufferEntries, opt);
+        await this.cfg.db.saveBatch(this.cfg.table, rawEntries, opt);
     }
-    async saveBatchAsBuffer(entries, opt) {
+    async saveBatchRaw(entries, opt) {
         await this.cfg.db.saveBatch(this.cfg.table, entries, opt);
     }
     async deleteByIds(ids) {
@@ -124,13 +98,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) => {
+        return this.cfg.db.streamValues(this.cfg.table, limit).flatMap(async (raw) => {
             try {
-                return [await mapBufferToValue(buf)];
+                return [await transformer.rawToValue(raw)];
             }
             catch (err) {
                 this.cfg.logger.error(err);
@@ -141,13 +115,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]) => {
+        return this.cfg.db.streamEntries(this.cfg.table, limit).flatMap(async ([id, raw]) => {
             try {
-                return [[id, await mapBufferToValue(buf)]];
+                return [[id, await transformer.rawToValue(raw)]];
             }
             catch (err) {
                 this.cfg.logger.error(err);
@@ -173,7 +147,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.22.1",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/adapter/inmemory/inMemoryKeyValueDB.ts

@@ -1,11 +1,11 @@
 import { Readable } from 'node:stream'
-import { _stringMapEntries, 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,
   commonKeyValueDBFullSupport,
-  KeyValueDBTuple,
+  IncrementTuple,
 } from '../../kv/commonKeyValueDB'
 
 export interface InMemoryKeyValueDBCfg {}
@@ -17,8 +17,8 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
     ...commonKeyValueDBFullSupport,
   }
 
-  // data[table][id] > Buffer
-  data: StringMap<StringMap<Buffer>> = {}
+  // data[table][id] => V
+  data: StringMap<StringMap<any>> = {}
 
   async ping(): Promise<void> {}
 
@@ -29,26 +29,25 @@ 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[]> {
+  async getByIds<V>(table: string, ids: string[]): Promise<KeyValueTuple<string, V>[]> {
     this.data[table] ||= {}
-    return ids.map(id => [id, this.data[table]![id]!] as KeyValueDBTuple).filter(e => e[1])
+    return ids.map(id => [id, this.data[table]![id]!] as KeyValueTuple<string, V>).filter(e => e[1])
   }
 
-  async saveBatch(table: string, entries: KeyValueDBTuple[]): Promise<void> {
+  async saveBatch<V>(table: string, entries: KeyValueTuple<string, V>[]): 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> {
     return Readable.from(Object.keys(this.data[table] || {}).slice(0, limit))
   }
 
-  streamValues(table: string, limit?: number): ReadableTyped<Buffer> {
+  streamValues<V>(table: string, limit?: number): ReadableTyped<V> {
     return Readable.from(Object.values(this.data[table] || {}).slice(0, limit))
   }
 
-  streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple> {
+  streamEntries<V>(table: string, limit?: number): ReadableTyped<KeyValueTuple<string, V>> {
     return Readable.from(Object.entries(this.data[table] || {}).slice(0, limit))
   }
 
@@ -57,28 +56,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, KeyValueTuple, UnixTimestampNumber } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDBCreateOptions } from '../db.model'
 
@@ -29,48 +29,41 @@ 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: (
+  saveBatch: <V>(
     table: string,
-    entries: KeyValueDBTuple[],
+    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>
 
-  /**
-   * 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 {
   /**

package/src/kv/commonKeyValueDao.ts

@@ -5,10 +5,10 @@ import { CommonDBCreateOptions } from '../db.model'
 import {
   CommonKeyValueDB,
   CommonKeyValueDBSaveBatchOptions,
-  KeyValueDBTuple,
+  IncrementTuple,
 } from './commonKeyValueDB'
 
-export interface CommonKeyValueDaoCfg<V> {
+export interface CommonKeyValueDaoCfg<RAW_V, V = RAW_V> {
   db: CommonKeyValueDB
 
   table: string
@@ -34,44 +34,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, RAW_V>
 }
 
 export type CommonKeyValueDaoSaveOptions = CommonKeyValueDBSaveBatchOptions
 
+export interface CommonKeyValueDaoTransformer<V, RAW_V> {
+  valueToRaw: (v: V) => Promise<RAW_V>
+  rawToValue: (raw: RAW_V) => Promise<V>
+}
+
+export const commonKeyValueDaoDeflatedJsonTransformer: CommonKeyValueDaoTransformer<any, Buffer> = {
+  valueToRaw: async v => await deflateString(JSON.stringify(v)),
+  rawToValue: async raw => JSON.parse(await inflateToString(raw)),
+}
+
 // todo: logging
 // todo: readonly
 
-export class CommonKeyValueDao<V, K extends string = string> {
-  constructor(cfg: CommonKeyValueDaoCfg<V>) {
+export class CommonKeyValueDao<K extends string, RAW_V, V = RAW_V> {
+  constructor(cfg: CommonKeyValueDaoCfg<RAW_V, 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']>
+  cfg: CommonKeyValueDaoCfg<RAW_V, V> & {
     logger: CommonLogger
   }
 
@@ -83,21 +72,15 @@ 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])
     return r?.[1] || null
   }
 
-  async getByIdAsBuffer(id?: K): Promise<Buffer | null> {
+  async getByIdRaw(id?: K): Promise<RAW_V | null> {
     if (!id) return null
-    const [r] = await this.cfg.db.getByIds(this.cfg.table, [id])
+    const [r] = await this.cfg.db.getByIds<RAW_V>(this.cfg.table, [id])
     return r?.[1] || null
   }
 
@@ -115,8 +98,8 @@ export class CommonKeyValueDao<V, K extends string = string> {
     return r[1]
   }
 
-  async requireByIdAsBuffer(id: K): Promise<Buffer> {
-    const [r] = await this.cfg.db.getByIds(this.cfg.table, [id])
+  async requireByIdRaw(id: K): Promise<RAW_V> {
+    const [r] = await this.cfg.db.getByIds<RAW_V>(this.cfg.table, [id])
 
     if (!r) {
       const { table } = this.cfg
@@ -129,46 +112,25 @@ 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
+    const entries = await this.cfg.db.getByIds<RAW_V>(this.cfg.table, ids)
+    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!.rawToValue(raw),
     ])
   }
 
-  async getByIdsAsBuffer(ids: K[]): Promise<KeyValueTuple<K, Buffer>[]> {
-    return (await this.cfg.db.getByIds(this.cfg.table, ids)) as KeyValueTuple<K, Buffer>[]
+  async getByIdsRaw(ids: K[]): Promise<KeyValueTuple<K, RAW_V>[]> {
+    return (await this.cfg.db.getByIds(this.cfg.table, ids)) as KeyValueTuple<K, RAW_V>[]
   }
 
   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> {
+  async saveRaw(id: K, value: RAW_V, opt?: CommonKeyValueDaoSaveOptions): Promise<void> {
     await this.cfg.db.saveBatch(this.cfg.table, [[id, value]], opt)
   }
 
@@ -176,20 +138,20 @@ export class CommonKeyValueDao<V, K extends string = string> {
     entries: KeyValueTuple<K, V>[],
     opt?: CommonKeyValueDaoSaveOptions,
   ): Promise<void> {
-    const { mapValueToBuffer } = this.cfg.hooks
-    let bufferEntries: KeyValueDBTuple[]
+    const { transformer } = this.cfg
+    let rawEntries: KeyValueTuple<string, RAW_V>[]
 
-    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.valueToRaw(v)])
     }
 
-    await this.cfg.db.saveBatch(this.cfg.table, bufferEntries, opt)
+    await this.cfg.db.saveBatch(this.cfg.table, rawEntries, opt)
   }
 
-  async saveBatchAsBuffer(
-    entries: KeyValueDBTuple[],
+  async saveBatchRaw(
+    entries: KeyValueTuple<K, RAW_V>[],
     opt?: CommonKeyValueDaoSaveOptions,
   ): Promise<void> {
     await this.cfg.db.saveBatch(this.cfg.table, entries, opt)
@@ -208,16 +170,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) {
-      return this.cfg.db.streamValues(this.cfg.table, limit) as ReadableTyped<V>
+    if (!transformer) {
+      return this.cfg.db.streamValues<V>(this.cfg.table, limit)
     }
 
-    return this.cfg.db.streamValues(this.cfg.table, limit).flatMap(
-      async buf => {
+    return this.cfg.db.streamValues<RAW_V>(this.cfg.table, limit).flatMap(
+      async raw => {
         try {
-          return [await mapBufferToValue(buf)]
+          return [await transformer.rawToValue(raw)]
         } catch (err) {
           this.cfg.logger.error(err)
           return [] // SKIP
@@ -230,18 +192,18 @@ 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) {
-      return this.cfg.db.streamEntries(this.cfg.table, limit) as ReadableTyped<KeyValueTuple<K, V>>
+    if (!transformer) {
+      return this.cfg.db.streamEntries<V>(this.cfg.table, limit) as any
     }
 
     return (
-      this.cfg.db.streamEntries(this.cfg.table, limit) as ReadableTyped<KeyValueTuple<K, Buffer>>
+      this.cfg.db.streamEntries(this.cfg.table, limit) as ReadableTyped<KeyValueTuple<K, RAW_V>>
     ).flatMap(
-      async ([id, buf]) => {
+      async ([id, raw]) => {
         try {
-          return [[id, await mapBufferToValue(buf)]]
+          return [[id, await transformer.rawToValue(raw)]]
         } catch (err) {
           this.cfg.logger.error(err)
           return [] // SKIP
@@ -272,6 +234,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 () => {
@@ -47,7 +50,7 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
   test('saveBatch, then getByIds', async () => {
     await db.saveBatch(TEST_TABLE, testEntries)
 
-    const entries = await db.getByIds(TEST_TABLE, testIds)
+    const entries = await db.getByIds<Buffer>(TEST_TABLE, testIds)
     _sortBy(entries, e => e[0], true)
     expect(entries).toEqual(testEntries)
   })
@@ -73,26 +76,26 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
   })
 
   test('streamValues', async () => {
-    const values = await db.streamValues(TEST_TABLE).toArray()
+    const values = await db.streamValues<Buffer>(TEST_TABLE).toArray()
     values.sort()
     expect(values).toEqual(testEntries.map(e => e[1]))
   })
 
   test('streamValues limited', async () => {
-    const valuesLimited = await db.streamValues(TEST_TABLE, 2).toArray()
+    const valuesLimited = await db.streamValues<Buffer>(TEST_TABLE, 2).toArray()
     // valuesLimited.sort()
     // expect(valuesLimited).toEqual(testEntries.map(e => e[1]).slice(0, 2))
     expect(valuesLimited.length).toBe(2)
   })
 
   test('streamEntries', async () => {
-    const entries = await db.streamEntries(TEST_TABLE).toArray()
+    const entries = await db.streamEntries<Buffer>(TEST_TABLE).toArray()
     entries.sort()
     expect(entries).toEqual(testEntries)
   })
 
   test('streamEntries limited', async () => {
-    const entriesLimited = await db.streamEntries(TEST_TABLE, 2).toArray()
+    const entriesLimited = await db.streamEntries<Buffer>(TEST_TABLE, 2).toArray()
     // entriesLimited.sort()
     // expect(entriesLimited).toEqual(testEntries.slice(0, 2))
     expect(entriesLimited.length).toBe(2)
@@ -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,
+      })
+    })
   }
 }