@naturalcycles/db-lib 8.46.1 → 8.48.0

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

@@ -3,7 +3,7 @@ import { Readable } from 'node:stream';
 import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { BaseCommonDB } from '../../base.common.db';
 import { CommonDB } from '../../common.db';
-import { CommonDBOptions, RunQueryResult } from '../../db.model';
+import { CommonDBOptions, DBPatch, RunQueryResult } from '../../db.model';
 import { DBQuery } from '../../query/dbQuery';
 import { DBTransaction } from '../../transaction/dbTransaction';
 import { CacheDBCfg, CacheDBCreateOptions, CacheDBOptions, CacheDBSaveOptions, CacheDBStreamOptions } from './cache.db.model';
@@ -23,12 +23,11 @@ export declare class CacheDB extends BaseCommonDB implements CommonDB {
     getTables(): Promise<string[]>;
     getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
     createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CacheDBCreateOptions): Promise<void>;
-    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], opt?: CacheDBSaveOptions<ROW>): Promise<ROW[]>;
-    deleteByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], opt?: CacheDBOptions): Promise<number>;
     saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CacheDBSaveOptions<ROW>): Promise<void>;
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBSaveOptions<ROW>): Promise<RunQueryResult<ROW>>;
     runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBStreamOptions): Readable;
     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>;
     commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void>;
 }

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

@@ -42,57 +42,6 @@ class CacheDB extends base_common_db_1.BaseCommonDB {
             await this.cfg.cacheDB.createTable(table, schema, opt);
         }
     }
-    async getByIds(table, ids, opt = {}) {
-        const resultMap = {};
-        const missingIds = [];
-        if (!opt.skipCache && !this.cfg.skipCache) {
-            const results = await this.cfg.cacheDB.getByIds(table, ids, opt);
-            results.forEach(r => (resultMap[r.id] = r));
-            missingIds.push(...ids.filter(id => !resultMap[id]));
-            if (this.cfg.logCached) {
-                this.cfg.logger?.log(`${table}.getByIds ${results.length} rows from cache: [${results
-                    .map(r => r.id)
-                    .join(', ')}]`);
-            }
-        }
-        if (missingIds.length && !opt.onlyCache && !this.cfg.onlyCache) {
-            const results = await this.cfg.downstreamDB.getByIds(table, missingIds, opt);
-            results.forEach(r => (resultMap[r.id] = r));
-            if (this.cfg.logDownstream) {
-                this.cfg.logger?.log(`${table}.getByIds ${results.length} rows from downstream: [${results
-                    .map(r => r.id)
-                    .join(', ')}]`);
-            }
-            if (!opt.skipCache) {
-                const cacheResult = this.cfg.cacheDB.saveBatch(table, results, opt);
-                if (this.cfg.awaitCache)
-                    await cacheResult;
-            }
-        }
-        // return in right order
-        return ids.map(id => resultMap[id]).filter(Boolean);
-    }
-    async deleteByIds(table, ids, opt = {}) {
-        let deletedIds = 0;
-        if (!opt.onlyCache && !this.cfg.onlyCache) {
-            deletedIds = await this.cfg.downstreamDB.deleteByIds(table, ids, opt);
-            if (this.cfg.logDownstream) {
-                this.cfg.logger?.log(`${table}.deleteByIds ${deletedIds} rows from downstream`);
-            }
-        }
-        if (!opt.skipCache && !this.cfg.skipCache) {
-            const cacheResult = this.cfg.cacheDB
-                .deleteByIds(table, ids, opt)
-                .then(deletedFromCache => {
-                if (this.cfg.logCached) {
-                    this.cfg.logger?.log(`${table}.deleteByIds ${deletedFromCache} rows from cache`);
-                }
-            });
-            if (this.cfg.awaitCache)
-                await cacheResult;
-        }
-        return deletedIds;
-    }
     async saveBatch(table, rows, opt = {}) {
         if (!opt.onlyCache && !this.cfg.onlyCache) {
             await this.cfg.downstreamDB.saveBatch(table, rows, opt);
@@ -195,6 +144,18 @@ class CacheDB extends base_common_db_1.BaseCommonDB {
         }
         return deletedIds;
     }
+    async updateByQuery(q, patch, opt = {}) {
+        let updated;
+        if (!opt.onlyCache && !this.cfg.onlyCache) {
+            updated = await this.cfg.downstreamDB.updateByQuery(q, patch, opt);
+        }
+        if (!opt.skipCache && !this.cfg.skipCache) {
+            const cacheResult = this.cfg.cacheDB.updateByQuery(q, patch, opt);
+            if (this.cfg.awaitCache)
+                updated ??= await cacheResult;
+        }
+        return updated || 0;
+    }
     async commitTransaction(tx, opt) {
         await this.cfg.downstreamDB.commitTransaction(tx, opt);
         await this.cfg.cacheDB.commitTransaction(tx, opt);

package/dist/adapter/file/file.db.d.ts

@@ -21,7 +21,6 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     cfg: FileDBCfg;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
     saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     /**
      * Implementation is optimized for loading/saving _whole files_.
@@ -30,7 +29,6 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     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?: CommonDBStreamOptions): ReadableTyped<ROW>;
-    deleteByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<number>;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
     loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;

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

@@ -34,10 +34,6 @@ class FileDB extends __1.BaseCommonDB {
         this.logFinished(started, `getTables() ${tables.length} tables`);
         return tables;
     }
-    async getByIds(table, ids, _opt) {
-        const byId = (0, js_lib_1._by)(await this.loadFile(table), r => r.id);
-        return ids.map(id => byId[id]).filter(Boolean);
-    }
     async saveBatch(table, rows, _opt) {
         if (!rows.length)
             return; // save some api calls
@@ -130,22 +126,6 @@ class FileDB extends __1.BaseCommonDB {
         });
         return readable;
     }
-    async deleteByIds(table, ids, _opt) {
-        if (!ids.length)
-            return 0;
-        let deleted = 0;
-        const rows = (await this.loadFile(table)).filter(r => {
-            if (ids.includes(r.id)) {
-                deleted++;
-                return false;
-            }
-            return true;
-        });
-        if (deleted > 0) {
-            await this.saveFile(table, rows);
-        }
-        return deleted;
-    }
     async deleteByQuery(q, _opt) {
         const byId = (0, js_lib_1._by)(await this.loadFile(q.table), r => r.id);
         let deleted = 0;

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

@@ -1,6 +1,6 @@
 import { JsonSchemaObject, StringMap, JsonSchemaRootObject, ObjectWithId, CommonLogger } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { CommonDB, DBTransaction } from '../..';
+import { CommonDB, DBPatch, DBTransaction } from '../..';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, RunQueryResult } from '../../db.model';
 import { DBQuery } from '../../query/dbQuery';
 export interface InMemoryDBCfg {
@@ -52,10 +52,9 @@ export declare class InMemoryDB implements CommonDB {
     getTables(): Promise<string[]>;
     getTableSchema<ROW extends ObjectWithId>(_table: string): Promise<JsonSchemaRootObject<ROW>>;
     createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
-    getByIds<ROW extends ObjectWithId>(_table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
     saveBatch<ROW extends Partial<ObjectWithId>>(_table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    deleteByIds<ROW extends ObjectWithId>(_table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<number>;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<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>;

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

@@ -8,6 +8,7 @@ const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const colors_1 = require("@naturalcycles/nodejs-lib/dist/colors");
 const fs = require("fs-extra");
 const __1 = require("../..");
+const dbQuery_1 = require("../../query/dbQuery");
 class InMemoryDB {
     constructor(cfg) {
         // data[table][id] > {id: 'a', created: ... }
@@ -66,11 +67,6 @@ class InMemoryDB {
             this.data[table] ||= {};
         }
     }
-    async getByIds(_table, ids, _opt) {
-        const table = this.cfg.tablesPrefix + _table;
-        this.data[table] ||= {};
-        return ids.map(id => this.data[table][id]).filter(Boolean);
-    }
     async saveBatch(_table, rows, opt = {}) {
         const table = this.cfg.tablesPrefix + _table;
         this.data[table] ||= {};
@@ -91,23 +87,35 @@ class InMemoryDB {
             this.data[table][r.id] = JSON.parse(JSON.stringify(r), nodejs_lib_1.bufferReviver);
         });
     }
-    async deleteByIds(_table, ids, _opt) {
-        const table = this.cfg.tablesPrefix + _table;
+    async deleteByQuery(q, _opt) {
+        const table = this.cfg.tablesPrefix + q.table;
         this.data[table] ||= {};
-        return ids
-            .map(id => {
-            const exists = !!this.data[table][id];
-            delete this.data[table][id];
-            if (exists)
-                return id;
-        })
-            .filter(Boolean).length;
+        let count = 0;
+        (0, __1.queryInMemory)(q, Object.values(this.data[table] || {})).forEach(r => {
+            if (!this.data[table][r.id])
+                return;
+            delete this.data[table][r.id];
+            count++;
+        });
+        return count;
     }
-    async deleteByQuery(q, _opt) {
+    async updateByQuery(q, patch) {
+        const patchEntries = Object.entries(patch);
+        if (!patchEntries.length)
+            return 0;
         const table = this.cfg.tablesPrefix + q.table;
         const rows = (0, __1.queryInMemory)(q, Object.values(this.data[table] || {}));
-        const ids = rows.map(r => r.id);
-        return await this.deleteByIds(q.table, ids);
+        rows.forEach((row) => {
+            patchEntries.forEach(([k, v]) => {
+                if (v instanceof __1.DBIncrement) {
+                    row[k] = (row[k] || 0) + v.amount;
+                }
+                else {
+                    row[k] = v;
+                }
+            });
+        });
+        return rows.length;
     }
     async runQuery(q, _opt) {
         const table = this.cfg.tablesPrefix + q.table;
@@ -129,7 +137,10 @@ class InMemoryDB {
                     await this.saveBatch(op.table, op.rows, { ...op.opt, ...opt });
                 }
                 else if (op.type === 'deleteByIds') {
-                    await this.deleteByIds(op.table, op.ids, { ...op.opt, ...opt });
+                    await this.deleteByQuery(dbQuery_1.DBQuery.create(op.table).filter('id', 'in', op.ids), {
+                        ...op.opt,
+                        ...opt,
+                    });
                 }
                 else {
                     throw new Error(`DBOperation not supported: ${op.type}`);
@@ -147,9 +158,7 @@ class InMemoryDB {
      * Flushes all tables (all namespaces) at once.
      */
     async flushToDisk() {
-        if (!this.cfg.persistenceEnabled) {
-            throw new Error('flushToDisk() called but persistenceEnabled=false');
-        }
+        (0, js_lib_1._assert)(this.cfg.persistenceEnabled, 'flushToDisk() called but persistenceEnabled=false');
         const { persistentStoragePath, persistZip } = this.cfg;
         const started = Date.now();
         await fs.emptyDir(persistentStoragePath);
@@ -175,9 +184,7 @@ class InMemoryDB {
      * Restores all tables (all namespaces) at once.
      */
     async restoreFromDisk() {
-        if (!this.cfg.persistentStoragePath) {
-            throw new Error('restoreFromDisk() called but persistenceEnabled=false');
-        }
+        (0, js_lib_1._assert)(this.cfg.persistenceEnabled, 'restoreFromDisk() called but persistenceEnabled=false');
         const { persistentStoragePath } = this.cfg;
         const started = Date.now();
         await fs.ensureDir(persistentStoragePath);

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

@@ -1,7 +1,7 @@
 import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDB } from './common.db';
-import { CommonDBOptions, CommonDBSaveOptions, RunQueryResult } from './db.model';
+import { CommonDBOptions, CommonDBSaveOptions, DBPatch, RunQueryResult } from './db.model';
 import { DBQuery } from './query/dbQuery';
 import { DBTransaction } from './transaction/dbTransaction';
 /**
@@ -12,14 +12,13 @@ export declare class BaseCommonDB implements CommonDB {
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
     getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
-    createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>): Promise<void>;
-    deleteByIds<ROW extends ObjectWithId>(_table: string, _ids: ROW['id'][]): Promise<number>;
-    deleteByQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<number>;
-    getByIds<ROW extends ObjectWithId>(_table: string, _ids: ROW['id'][]): Promise<ROW[]>;
-    runQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<RunQueryResult<ROW>>;
-    runQueryCount<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<number>;
-    saveBatch<ROW extends Partial<ObjectWithId>>(_table: string, _rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    streamQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): ReadableTyped<ROW>;
+    createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>): Promise<void>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number>;
+    updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<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 Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): ReadableTyped<ROW>;
     /**
      * Naive implementation.
      * Doesn't support rollback on error, hence doesn't pass dbTest.

package/dist/base.common.db.js

@@ -1,45 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseCommonDB = void 0;
-const node_stream_1 = require("node:stream");
-const dbTransaction_util_1 = require("./transaction/dbTransaction.util");
+/* eslint-disable unused-imports/no-unused-vars */
 /**
  * No-op implementation of CommonDB interface.
  * To be extended by actual implementations.
  */
 class BaseCommonDB {
-    async ping() { }
+    async ping() {
+        throw new Error('ping is not implemented');
+    }
     async getTables() {
-        return [];
+        throw new Error('getTables is not implemented');
     }
     async getTableSchema(table) {
-        return {
-            $id: `${table}.schema.json`,
-            type: 'object',
-            additionalProperties: true,
-            properties: {},
-            required: [],
-        };
+        throw new Error('getTableSchema is not implemented');
+    }
+    async createTable(table, schema) {
+        // no-op
     }
-    async createTable(_table, _schema) { }
-    async deleteByIds(_table, _ids) {
-        return 0;
+    async deleteByQuery(q) {
+        throw new Error('deleteByQuery is not implemented');
     }
-    async deleteByQuery(_q) {
-        return 0;
+    async updateByQuery(q, patch, opt) {
+        throw new Error('updateByQuery is not implemented');
     }
-    async getByIds(_table, _ids) {
-        return [];
+    async runQuery(q) {
+        throw new Error('runQuery is not implemented');
     }
-    async runQuery(_q) {
-        return { rows: [] };
+    async runQueryCount(q) {
+        throw new Error('runQueryCount is not implemented');
     }
-    async runQueryCount(_q) {
-        return 0;
+    async saveBatch(table, rows, opt) {
+        throw new Error('saveBatch is not implemented');
     }
-    async saveBatch(_table, _rows, _opt) { }
-    streamQuery(_q) {
-        return node_stream_1.Readable.from([]);
+    streamQuery(q) {
+        throw new Error('streamQuery is not implemented');
     }
     /**
      * Naive implementation.
@@ -47,7 +43,7 @@ class BaseCommonDB {
      * To be extended.
      */
     async commitTransaction(tx, opt) {
-        await (0, dbTransaction_util_1.commitDBTransactionSimple)(this, tx, opt);
+        throw new Error('commitTransaction 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 { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, RunQueryResult } from './db.model';
+import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, DBPatch, RunQueryResult } from './db.model';
 import { DBQuery } from './query/dbQuery';
 import { DBTransaction } from './transaction/dbTransaction';
 export interface CommonDB {
@@ -27,11 +27,6 @@ export interface CommonDB {
      * Caution! dropIfExists defaults to false. If set to true - will actually DROP the table!
      */
     createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
-    /**
-     * Order of items returned is not guaranteed to match order of ids.
-     * (Such limitation exists because Datastore doesn't support it).
-     */
-    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], opt?: CommonDBOptions): Promise<ROW[]>;
     /**
      * Order by 'id' is not supported by all implementations (for example, Datastore doesn't support it).
      */
@@ -46,8 +41,26 @@ export interface CommonDB {
      * Returns number of deleted items.
      * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
      */
-    deleteByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], opt?: CommonDBOptions): Promise<number>;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<number>;
+    /**
+     * Applies patch to the rows returned by the query.
+     *
+     * Example:
+     *
+     * UPDATE table SET A = B where $QUERY_CONDITION
+     *
+     * 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.
+     */
+    updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<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.

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

@@ -1,6 +1,6 @@
 import { AnyObject, AsyncMapper, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, Saved, Unsaved } from '@naturalcycles/js-lib';
 import { AjvSchema, ObjectSchemaTyped, ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { DBDeleteByIdsOperation, DBModelType, DBOperation, DBSaveBatchOperation, RunQueryResult } from '../db.model';
+import { DBDeleteByIdsOperation, DBModelType, DBOperation, DBPatch, DBSaveBatchOperation, RunQueryResult } from '../db.model';
 import { DBQuery, RunnableDBQuery } from '../query/dbQuery';
 import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions } from './common.dao.model';
 /**
@@ -120,6 +120,9 @@ export declare class CommonDao<BM extends Partial<ObjectWithId<ID>>, DBM extends
     deleteByQuery(q: DBQuery<DBM>, opt?: CommonDaoStreamForEachOptions<DBM> & {
         stream?: boolean;
     }): 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>;
     dbmToBM(_dbm: undefined, opt?: CommonDaoOptions): Promise<undefined>;
     dbmToBM(_dbm?: DBM, opt?: CommonDaoOptions): Promise<Saved<BM>>;
     dbmsToBM(dbms: DBM[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;

package/dist/commondao/common.dao.js

@@ -112,13 +112,15 @@ class CommonDao {
         let dbm;
         if (opt.timeout) {
             // todo: possibly remove it after debugging is done
-            dbm = (await (0, js_lib_1.pTimeout)(() => this.cfg.db.getByIds(table, [id]), {
+            dbm = await (0, js_lib_1.pTimeout)(async () => {
+                return (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id))).rows[0];
+            }, {
                 timeout: opt.timeout,
                 name: `getById(${table})`,
-            }))[0];
+            });
         }
         else {
-            dbm = (await this.cfg.db.getByIds(table, [id]))[0];
+            dbm = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id))).rows[0];
         }
         const bm = opt.raw ? dbm : await this.dbmToBM(dbm, opt);
         this.logResult(started, op, bm, table);
@@ -143,7 +145,7 @@ class CommonDao {
         const op = `getByIdAsDBM(${id})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        let [dbm] = await this.cfg.db.getByIds(table, [id]);
+        let [dbm] = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id))).rows;
         if (!opt.raw) {
             dbm = this.anyToDBM(dbm, opt);
         }
@@ -156,7 +158,7 @@ class CommonDao {
         const op = `getByIdAsTM(${id})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const [dbm] = await this.cfg.db.getByIds(table, [id]);
+        const [dbm] = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id))).rows;
         if (opt.raw) {
             this.logResult(started, op, dbm, table);
             return dbm || null;
@@ -170,7 +172,7 @@ class CommonDao {
         const op = `getByIds ${ids.length} id(s) (${(0, js_lib_1._truncate)(ids.slice(0, 10).join(', '), 50)})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const dbms = await this.cfg.db.getByIds(table, ids);
+        const dbms = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterIn('id', ids))).rows;
         const bms = opt.raw ? dbms : await this.dbmsToBM(dbms, opt);
         this.logResult(started, op, bms, table);
         return bms;
@@ -179,7 +181,7 @@ class CommonDao {
         const op = `getByIdsAsDBM ${ids.length} id(s) (${(0, js_lib_1._truncate)(ids.slice(0, 10).join(', '), 50)})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const dbms = await this.cfg.db.getByIds(table, ids);
+        const dbms = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterIn('id', ids))).rows;
         this.logResult(started, op, dbms, table);
         return dbms;
     }
@@ -229,7 +231,8 @@ class CommonDao {
     }
     async ensureUniqueId(table, dbm) {
         // todo: retry N times
-        const existing = await this.cfg.db.getByIds(table, [dbm.id]);
+        const existing = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', dbm.id)))
+            .rows;
         if (existing.length) {
             throw new js_lib_1.AppError(cnst_1.DBLibError.NON_UNIQUE_ID, {
                 table,
@@ -656,9 +659,9 @@ class CommonDao {
         const op = `deleteById(${id})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const ids = await this.cfg.db.deleteByIds(table, [id]);
+        const count = await this.cfg.db.deleteByQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id));
         this.logSaveResult(started, op, table);
-        return ids;
+        return count;
     }
     async deleteByIds(ids, opt = {}) {
         this.requireWriteAccess();
@@ -666,9 +669,9 @@ class CommonDao {
         const op = `deleteByIds(${ids.join(', ')})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const deletedIds = await this.cfg.db.deleteByIds(table, ids);
+        const count = await this.cfg.db.deleteByQuery(dbQuery_1.DBQuery.create(table).filterIn('id', ids));
         this.logSaveResult(started, op, table);
-        return deletedIds;
+        return count;
     }
     /**
      * Pass `stream: true` option to use Streaming: it will Stream the query, batch by 500, and execute
@@ -691,7 +694,7 @@ class CommonDao {
                 }),
                 (0, nodejs_lib_1.transformBuffer)({ batchSize }),
                 (0, nodejs_lib_1.transformMap)(async (ids) => {
-                    deleted += await this.cfg.db.deleteByIds(q.table, ids, opt);
+                    deleted += await this.cfg.db.deleteByQuery(dbQuery_1.DBQuery.create(q.table).filterIn('id', ids), opt);
                 }, {
                     predicate: js_lib_1._passthroughPredicate,
                 }),
@@ -711,6 +714,22 @@ 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 = {}) {
+        return await this.updateByQuery(this.query().filterIn('id', ids), patch, opt);
+    }
+    async updateByQuery(q, patch, opt = {}) {
+        this.requireWriteAccess();
+        this.requireObjectMutability(opt);
+        q.table = opt.table || q.table;
+        const op = `updateByQuery(${q.pretty()})`;
+        const started = this.logStarted(op, q.table);
+        const updated = await this.cfg.db.updateByQuery(q, patch, opt);
+        this.logSaveResult(started, op, q.table);
+        return updated;
+    }
     async dbmToBM(_dbm, opt = {}) {
         if (!_dbm)
             return;

package/dist/db.model.d.ts

@@ -62,3 +62,16 @@ export declare enum DBModelType {
     BM = "BM",
     TM = "TM"
 }
+/**
+ * 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 Partial<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.DBModelType = exports.DBRelation = void 0;
+exports.DBIncrement = exports.DBModelType = exports.DBRelation = void 0;
 var DBRelation;
 (function (DBRelation) {
     DBRelation["ONE_TO_ONE"] = "ONE_TO_ONE";
@@ -12,3 +12,19 @@ var DBModelType;
     DBModelType["BM"] = "BM";
     DBModelType["TM"] = "TM";
 })(DBModelType = exports.DBModelType || (exports.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/query/dbQuery.d.ts

@@ -1,6 +1,6 @@
 import { AnyObjectWithId, ObjectWithId, AsyncMapper, Saved, AnyObject } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
-import { CommonDaoOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions } from '..';
+import { CommonDaoOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, DBPatch } from '..';
 import { CommonDao } from '../commondao/common.dao';
 import { RunQueryResult } from '../db.model';
 /**
@@ -68,6 +68,7 @@ export declare class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     _distinct: boolean;
     filter(name: keyof ROW, op: DBQueryFilterOperator, val: any): this;
     filterEq(name: keyof ROW, val: any): this;
+    filterIn(name: keyof ROW, val: any[]): this;
     limit(limit: number): this;
     offset(offset: number): this;
     order(name: keyof ROW, descending?: boolean): this;
@@ -97,6 +98,7 @@ export declare class RunnableDBQuery<BM extends Partial<ObjectWithId<ID>>, DBM e
     runQueryExtendedAsDBM(opt?: CommonDaoOptions): Promise<RunQueryResult<DBM>>;
     runQueryExtendedAsTM(opt?: CommonDaoOptions): Promise<RunQueryResult<TM>>;
     runQueryCount(opt?: CommonDaoOptions): Promise<number>;
+    updateByQuery(patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
     streamQueryForEach(mapper: AsyncMapper<Saved<BM>, void>, opt?: CommonDaoStreamForEachOptions<Saved<BM>>): Promise<void>;
     streamQueryAsDBMForEach(mapper: AsyncMapper<DBM, void>, opt?: CommonDaoStreamForEachOptions<DBM>): Promise<void>;
     streamQuery(opt?: CommonDaoStreamOptions): ReadableTyped<Saved<BM>>;