@naturalcycles/db-lib 9.21.0 → 9.22.0

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

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

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

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

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

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

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

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

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

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

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

@@ -22,4 +22,5 @@ export declare class InMemoryKeyValueDB implements CommonKeyValueDB {
     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>>;
 }

package/dist/adapter/inmemory/inMemoryKeyValueDB.js

@@ -2,6 +2,7 @@
 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 = {}) {
@@ -18,6 +19,7 @@ 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]);
@@ -46,5 +48,16 @@ class InMemoryKeyValueDB {
         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;
+    }
 }
 exports.InMemoryKeyValueDB = InMemoryKeyValueDB;

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

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

package/dist/base.common.db.js

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

package/dist/common.db.d.ts

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

package/dist/common.db.js

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

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

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

package/dist/commondao/common.dao.js

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

package/dist/db.model.d.ts

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

package/dist/db.model.js

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

package/dist/kv/commonKeyValueDB.d.ts

@@ -1,4 +1,4 @@
-import { UnixTimestampNumber } from '@naturalcycles/js-lib';
+import { StringMap, UnixTimestampNumber } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBCreateOptions } from '../db.model';
 /**
@@ -33,13 +33,27 @@ export interface CommonKeyValueDB {
     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).
+     *
+     * Example:
+     * { key1: 2, key2: 3 }
+     * would increment `key1` by 2, and `key2` by 3.
+     *
+     * Returns the incrementMap with the same keys and updated values.
+     *
+     * @experimental
+     */
+    incrementBatch: (table: string, incrementMap: StringMap<number>) => Promise<StringMap<number>>;
 }
 export type KeyValueDBTuple = [key: string, value: Buffer];
 export interface CommonKeyValueDBSaveBatchOptions {

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 () => {