@naturalcycles/db-lib 9.20.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

@@ -7,6 +7,10 @@ export interface InMemoryKeyValueDBCfg {
 export declare class InMemoryKeyValueDB implements CommonKeyValueDB {
     cfg: InMemoryKeyValueDBCfg;
     constructor(cfg?: InMemoryKeyValueDBCfg);
+    support: {
+        count?: boolean;
+        increment?: boolean;
+    };
     data: StringMap<StringMap<Buffer>>;
     ping(): Promise<void>;
     createTable(_table: string, _opt?: CommonDBCreateOptions): Promise<void>;
@@ -18,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,9 +2,14 @@
 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 = {}) {
         this.cfg = cfg;
+        this.support = {
+            ...commonKeyValueDB_1.commonKeyValueDBFullSupport,
+        };
         // data[table][id] > Buffer
         this.data = {};
     }
@@ -14,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]);
@@ -42,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",
@@ -15,21 +15,6 @@ export interface CommonDB {
      * Manifest of supported features.
      */
     support: CommonDBSupport;
-    supportsQueries?: boolean;
-    supportsDBQueryFilter?: boolean;
-    supportsDBQueryFilterIn?: boolean;
-    supportsDBQueryOrder?: boolean;
-    supportsDBQuerySelectFields?: boolean;
-    supportsInsertSaveMethod?: boolean;
-    supportsUpdateSaveMethod?: boolean;
-    supportsUpdateByQuery?: boolean;
-    supportsDBIncrement?: boolean;
-    supportsCreateTable?: boolean;
-    supportsTableSchemas?: boolean;
-    supportsStreaming?: boolean;
-    supportsBufferValues?: boolean;
-    supportsNullValues?: boolean;
-    supportsTransactions?: boolean;
     /**
      * Checks that connection/credentials/etc is ok.
      * Also acts as a "warmup request" for a DB.
@@ -79,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:
      *
@@ -87,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.
@@ -109,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.
@@ -121,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,20 +1,16 @@
-import { UnixTimestampNumber } from '@naturalcycles/js-lib';
+import { StringMap, UnixTimestampNumber } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBCreateOptions } from '../db.model';
-export type KeyValueDBTuple = [key: string, value: Buffer];
-export interface CommonKeyValueDBSaveBatchOptions {
-    /**
-     * If set (and if it's implemented by the driver) - will set expiry TTL for each key of the batch.
-     * E.g EXAT in Redis.
-     */
-    expireAt?: UnixTimestampNumber;
-}
 /**
  * Common interface for Key-Value database implementations.
  *
  * @experimental
  */
 export interface CommonKeyValueDB {
+    /**
+     * Manifest of supported features.
+     */
+    support: CommonKeyValueDBSupport;
     /**
      * Check that DB connection is working properly.
      */
@@ -37,11 +33,41 @@ 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 {
+    /**
+     * If set (and if it's implemented by the driver) - will set expiry TTL for each key of the batch.
+     * E.g EXAT in Redis.
+     */
+    expireAt?: UnixTimestampNumber;
+}
+/**
+ * Manifest of supported features.
+ */
+export interface CommonKeyValueDBSupport {
+    count?: boolean;
+    increment?: boolean;
 }
+export declare const commonKeyValueDBFullSupport: CommonKeyValueDBSupport;

package/dist/kv/commonKeyValueDB.js

@@ -1,2 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonKeyValueDBFullSupport = void 0;
+exports.commonKeyValueDBFullSupport = {
+    count: true,
+    increment: true,
+};

package/dist/kv/commonKeyValueDao.d.ts

@@ -3,7 +3,7 @@ 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<T> {
+export interface CommonKeyValueDaoCfg<V> {
     db: CommonKeyValueDB;
     table: string;
     /**
@@ -24,9 +24,9 @@ export interface CommonKeyValueDaoCfg<T> {
      */
     logStarted?: boolean;
     hooks?: {
-        mapValueToBuffer?: (v: T) => Promise<Buffer>;
-        mapBufferToValue?: (b: Buffer) => Promise<T>;
-        beforeCreate?: (v: Partial<T>) => Partial<T>;
+        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
@@ -59,9 +59,12 @@ export declare class CommonKeyValueDao<V, K extends string = string> {
     saveBatchAsBuffer(entries: KeyValueDBTuple[], opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
     deleteByIds(ids: K[]): Promise<void>;
     deleteById(id: K): Promise<void>;
-    streamIds(limit?: number): ReadableTyped<string>;
+    streamIds(limit?: number): ReadableTyped<K>;
     streamValues(limit?: number): ReadableTyped<V>;
     streamEntries(limit?: number): ReadableTyped<KeyValueTuple<K, V>>;
+    getAllKeys(limit?: number): Promise<K[]>;
+    getAllValues(limit?: number): Promise<V[]>;
+    getAllEntries(limit?: number): Promise<KeyValueTuple<K, V>[]>;
     /**
      * Increments the `id` field by the amount specified in `by`,
      * or by 1 if `by` is not specified.

package/dist/kv/commonKeyValueDao.js

@@ -157,6 +157,15 @@ class CommonKeyValueDao {
             concurrency: 32,
         });
     }
+    async getAllKeys(limit) {
+        return await this.streamIds(limit).toArray();
+    }
+    async getAllValues(limit) {
+        return await this.streamValues(limit).toArray();
+    }
+    async getAllEntries(limit) {
+        return await this.streamEntries(limit).toArray();
+    }
     /**
      * Increments the `id` field by the amount specified in `by`,
      * or by 1 if `by` is not specified.

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);