@naturalcycles/db-lib 9.21.0 → 9.22.1

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/query/dbQuery.d.ts

@@ -1,6 +1,6 @@
 import { AsyncMapper, BaseDBEntity, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { CommonDaoOptions, CommonDaoStreamDeleteOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, DBPatch } from '..';
+import { CommonDaoOptions, CommonDaoStreamDeleteOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions } from '..';
 import { CommonDao } from '../commondao/common.dao';
 import { RunQueryResult } from '../db.model';
 /**
@@ -99,7 +99,7 @@ export declare class RunnableDBQuery<BM extends BaseDBEntity, DBM extends BaseDB
     runQueryExtended(opt?: CommonDaoOptions): Promise<RunQueryResult<BM>>;
     runQueryExtendedAsDBM(opt?: CommonDaoOptions): Promise<RunQueryResult<DBM>>;
     runQueryCount(opt?: CommonDaoOptions): Promise<number>;
-    updateByQuery(patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
+    patchByQuery(patch: Partial<DBM>, opt?: CommonDaoOptions): Promise<number>;
     streamQueryForEach(mapper: AsyncMapper<BM, void>, opt?: CommonDaoStreamForEachOptions<BM>): Promise<void>;
     streamQueryAsDBMForEach(mapper: AsyncMapper<DBM, void>, opt?: CommonDaoStreamForEachOptions<DBM>): Promise<void>;
     streamQuery(opt?: CommonDaoStreamOptions<BM>): ReadableTyped<BM>;

package/dist/query/dbQuery.js

@@ -165,8 +165,8 @@ class RunnableDBQuery extends DBQuery {
     async runQueryCount(opt) {
         return await this.dao.runQueryCount(this, opt);
     }
-    async updateByQuery(patch, opt) {
-        return await this.dao.updateByQuery(this, patch, opt);
+    async patchByQuery(patch, opt) {
+        return await this.dao.patchByQuery(this, patch, opt);
     }
     async streamQueryForEach(mapper, opt) {
         await this.dao.streamQueryForEach(this, mapper, opt);

package/dist/testing/daoTest.js

@@ -99,6 +99,32 @@ function runCommonDaoTest(db, quirks = {}) {
         expect(items[0]).toMatchObject(clone);
         (0, dbTest_1.expectMatch)(expectedItems, itemsSaved, quirks);
     });
+    if (support.increment) {
+        test('increment', async () => {
+            await dao.incrementBatch('k3', { id1: 1, id2: 2 });
+            let rows = await dao.query().runQuery();
+            rows = (0, js_lib_1._sortBy)(rows, r => r.id);
+            const expected = expectedItems.map(r => {
+                if (r.id === 'id1') {
+                    return {
+                        ...r,
+                        k3: r.k3 + 1,
+                    };
+                }
+                if (r.id === 'id2') {
+                    return {
+                        ...r,
+                        k3: r.k3 + 2,
+                    };
+                }
+                return r;
+            });
+            (0, dbTest_1.expectMatch)(expected, rows, quirks);
+            // reset the changes
+            await dao.increment('k3', 'id1', -1);
+            await dao.increment('k3', 'id2', -2);
+        });
+    }
     // GET not empty
     test('getByIds all items', async () => {
         const rows = await dao.getByIds(items.map(i => i.id).concat('abcd'));

package/dist/testing/dbTest.js

@@ -4,7 +4,6 @@ exports.runCommonDBTest = runCommonDBTest;
 exports.expectMatch = expectMatch;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const common_db_1 = require("../common.db");
-const db_model_1 = require("../db.model");
 const dbQuery_1 = require("../query/dbQuery");
 const test_model_1 = require("./test.model");
 function runCommonDBTest(db, quirks = {}) {
@@ -236,8 +235,8 @@ function runCommonDBTest(db, quirks = {}) {
             expectMatch(expected, rows, quirks);
         });
     }
-    if (support.updateByQuery) {
-        test('updateByQuery simple', async () => {
+    if (support.patchByQuery) {
+        test('patchByQuery', async () => {
             // cleanup, reset initial data
             await db.deleteByQuery(queryAll());
             await db.saveBatch(test_model_1.TEST_TABLE, items);
@@ -245,7 +244,7 @@ function runCommonDBTest(db, quirks = {}) {
                 k3: 5,
                 k2: 'abc',
             };
-            await db.updateByQuery(dbQuery_1.DBQuery.create(test_model_1.TEST_TABLE).filterEq('even', true), patch);
+            await db.patchByQuery(dbQuery_1.DBQuery.create(test_model_1.TEST_TABLE).filterEq('even', true), patch);
             const { rows } = await db.runQuery(queryAll());
             const expected = items.map(r => {
                 if (r.even) {
@@ -255,26 +254,25 @@ function runCommonDBTest(db, quirks = {}) {
             });
             expectMatch(expected, rows, quirks);
         });
-        if (support.dbIncrement) {
-            test('updateByQuery DBIncrement', async () => {
-                // cleanup, reset initial data
-                await db.deleteByQuery(queryAll());
-                await db.saveBatch(test_model_1.TEST_TABLE, items);
-                const patch = {
-                    k3: db_model_1.DBIncrement.of(1),
-                    k2: 'abcd',
-                };
-                await db.updateByQuery(dbQuery_1.DBQuery.create(test_model_1.TEST_TABLE).filterEq('even', true), patch);
-                const { rows } = await db.runQuery(queryAll());
-                const expected = items.map(r => {
-                    if (r.even) {
-                        return { ...r, ...patch, k3: (r.k3 || 0) + 1 };
-                    }
-                    return r;
-                });
-                expectMatch(expected, rows, quirks);
+    }
+    if (support.increment) {
+        test('incrementBatch', async () => {
+            // cleanup, reset initial data
+            await db.deleteByQuery(queryAll());
+            await db.saveBatch(test_model_1.TEST_TABLE, items);
+            await db.incrementBatch(test_model_1.TEST_TABLE, 'k3', { id1: 1, id2: 2 });
+            const { rows } = await db.runQuery(queryAll());
+            const expected = items.map(r => {
+                if (r.id === 'id1') {
+                    return { ...r, k3: 2 };
+                }
+                if (r.id === 'id2') {
+                    return { ...r, k3: 4 };
+                }
+                return r;
             });
-        }
+            expectMatch(expected, rows, quirks);
+        });
     }
     if (support.queries) {
         test('cleanup', async () => {

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,
@@ -86,17 +89,29 @@ function runCommonKeyValueDBTest(db) {
         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 db.increment(test_model_1.TEST_TABLE, 'nonExistingField');
-            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, 'nonExistingField');
-            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, 'nonExistingField', 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(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.21.0",
+  "version": "9.22.1",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/adapter/cachedb/cache.db.ts

@@ -9,7 +9,7 @@ import {
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { BaseCommonDB } from '../../base.common.db'
 import { CommonDB, commonDBFullSupport, CommonDBSupport } from '../../common.db'
-import { DBPatch, RunQueryResult } from '../../db.model'
+import { RunQueryResult } from '../../db.model'
 import { DBQuery } from '../../query/dbQuery'
 import {
   CacheDBCfg,
@@ -29,6 +29,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
   override support: CommonDBSupport = {
     ...commonDBFullSupport,
     transactions: false,
+    increment: false,
   }
 
   constructor(cfg: CacheDBCfg) {
@@ -271,19 +272,19 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     return deletedIds
   }
 
-  override async updateByQuery<ROW extends ObjectWithId>(
+  override async patchByQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    patch: DBPatch<ROW>,
+    patch: Partial<ROW>,
     opt: CacheDBOptions = {},
   ): Promise<number> {
     let updated: number | undefined
 
     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/src/adapter/file/file.db.ts

@@ -45,9 +45,10 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     bufferValues: false, // todo: implement
     insertSaveMethod: false,
     updateSaveMethod: false,
-    updateByQuery: false,
+    patchByQuery: false,
     createTable: false,
     transactions: false, // todo
+    increment: false,
   }
 
   constructor(cfg: FileDBCfg) {

package/src/adapter/inmemory/inMemory.db.ts

@@ -3,9 +3,12 @@ import {
   _assert,
   _by,
   _deepCopy,
+  _isEmptyObject,
   _since,
   _sortObjectDeep,
+  _stringMapEntries,
   _stringMapValues,
+  AnyObjectWithId,
   CommonLogger,
   generateJsonSchemaFromData,
   JsonSchemaObject,
@@ -27,9 +30,7 @@ import {
   commonDBFullSupport,
   CommonDBTransactionOptions,
   CommonDBType,
-  DBIncrement,
   DBOperation,
-  DBPatch,
   DBTransactionFn,
   queryInMemory,
 } from '../..'
@@ -113,7 +114,7 @@ export class InMemoryDB implements CommonDB {
   cfg: InMemoryDBCfg
 
   // data[table][id] > {id: 'a', created: ... }
-  data: StringMap<StringMap<ObjectWithId>> = {}
+  data: StringMap<StringMap<AnyObjectWithId>> = {}
 
   /**
    * Returns internal "Data snapshot".
@@ -233,25 +234,14 @@ export class InMemoryDB implements CommonDB {
     return count
   }
 
-  async updateByQuery<ROW extends ObjectWithId>(
+  async patchByQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    patch: DBPatch<ROW>,
+    patch: Partial<ROW>,
   ): Promise<number> {
-    const patchEntries = Object.entries(patch)
-    if (!patchEntries.length) return 0
-
+    if (_isEmptyObject(patch)) return 0
     const table = this.cfg.tablesPrefix + q.table
     const rows = queryInMemory(q, Object.values(this.data[table] || {}) as ROW[])
-    rows.forEach((row: any) => {
-      patchEntries.forEach(([k, v]) => {
-        if (v instanceof DBIncrement) {
-          row[k] = (row[k] || 0) + v.amount
-        } else {
-          row[k] = v
-        }
-      })
-    })
-
+    rows.forEach(row => Object.assign(row, patch))
     return rows.length
   }
 
@@ -294,6 +284,27 @@ export class InMemoryDB implements CommonDB {
     }
   }
 
+  async incrementBatch(
+    table: string,
+    prop: string,
+    incrementMap: StringMap<number>,
+    _opt?: CommonDBOptions,
+  ): Promise<StringMap<number>> {
+    const tbl = this.cfg.tablesPrefix + table
+    this.data[tbl] ||= {}
+
+    const result: StringMap<number> = {}
+
+    for (const [id, by] of _stringMapEntries(incrementMap)) {
+      this.data[tbl][id] ||= { id }
+      const newValue = ((this.data[tbl][id][prop] as number) || 0) + by
+      this.data[tbl][id][prop] = newValue
+      result[id] = newValue
+    }
+
+    return result
+  }
+
   /**
    * Flushes all tables (all namespaces) at once.
    */