@naturalcycles/db-lib 9.20.0 → 9.22.0

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

@@ -18,6 +18,7 @@ function runCommonKeyValueDBTest(db) {
         const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
         await db.deleteByIds(test_model_1.TEST_TABLE, ids);
     });
+    const { support } = db;
     test('ping', async () => {
         await db.ping();
     });
@@ -40,9 +41,11 @@ function runCommonKeyValueDBTest(db) {
         (0, js_lib_1._sortBy)(entries, e => e[0], true);
         expect(entries).toEqual(testEntries);
     });
-    test('count should be 3', async () => {
-        expect(await db.count(test_model_1.TEST_TABLE)).toBe(3);
-    });
+    if (support.count) {
+        test('count should be 3', async () => {
+            expect(await db.count(test_model_1.TEST_TABLE)).toBe(3);
+        });
+    }
     test('streamIds', async () => {
         const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
         ids.sort();
@@ -82,16 +85,30 @@ function runCommonKeyValueDBTest(db) {
         const results = await db.getByIds(test_model_1.TEST_TABLE, testIds);
         expect(results).toEqual([]);
     });
-    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);
-    });
-    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);
-    });
-    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);
-    });
+    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, id);
+            expect(result).toBe(1);
+        });
+        test('increment on a existing field should increase the value by one', async () => {
+            const result = await db.increment(test_model_1.TEST_TABLE, id);
+            expect(result).toBe(2);
+        });
+        test('increment should increase the value by the specified amount', async () => {
+            const result = await db.increment(test_model_1.TEST_TABLE, id, 2);
+            expect(result).toBe(4);
+        });
+        test('increment 2 ids at the same time', async () => {
+            const result = await db.incrementBatch(test_model_1.TEST_TABLE, {
+                [id]: 1,
+                [id2]: 2,
+            });
+            expect(result).toEqual({
+                [id]: 5,
+                [id2]: 2,
+            });
+        });
+    }
 }

package/dist/testing/keyValueDaoTest.js

@@ -17,6 +17,7 @@ function runCommonKeyValueDaoTest(dao) {
         const ids = await dao.streamIds().toArray();
         await dao.deleteByIds(ids);
     });
+    const { support } = dao.cfg.db;
     test('ping', async () => {
         await dao.ping();
     });
@@ -75,16 +76,18 @@ function runCommonKeyValueDaoTest(dao) {
         const results = await dao.getByIds(testIds);
         expect(results).toEqual([]);
     });
-    test('increment on a non-existing field should set the value to 1', async () => {
-        const result = await dao.increment('nonExistingField');
-        expect(result).toBe(1);
-    });
-    test('increment on a existing field should increase the value by one', async () => {
-        const result = await dao.increment('nonExistingField');
-        expect(result).toBe(2);
-    });
-    test('increment should increase the value by the specified amount', async () => {
-        const result = await dao.increment('nonExistingField', 2);
-        expect(result).toBe(4);
-    });
+    if (support.increment) {
+        test('increment on a non-existing field should set the value to 1', async () => {
+            const result = await dao.increment('nonExistingField');
+            expect(result).toBe(1);
+        });
+        test('increment on a existing field should increase the value by one', async () => {
+            const result = await dao.increment('nonExistingField');
+            expect(result).toBe(2);
+        });
+        test('increment should increase the value by the specified amount', async () => {
+            const result = await dao.increment('nonExistingField', 2);
+            expect(result).toBe(4);
+        });
+    }
 }

package/package.json

@@ -45,7 +45,7 @@
   "engines": {
     "node": ">=20.13"
   },
-  "version": "9.20.0",
+  "version": "9.22.0",
   "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.
    */

package/src/adapter/inmemory/inMemoryKeyValueDB.ts

@@ -1,14 +1,22 @@
 import { Readable } from 'node:stream'
-import { StringMap } from '@naturalcycles/js-lib'
+import { _stringMapEntries, StringMap } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDBCreateOptions } from '../../db.model'
-import { CommonKeyValueDB, KeyValueDBTuple } from '../../kv/commonKeyValueDB'
+import {
+  CommonKeyValueDB,
+  commonKeyValueDBFullSupport,
+  KeyValueDBTuple,
+} from '../../kv/commonKeyValueDB'
 
 export interface InMemoryKeyValueDBCfg {}
 
 export class InMemoryKeyValueDB implements CommonKeyValueDB {
   constructor(public cfg: InMemoryKeyValueDBCfg = {}) {}
 
+  support = {
+    ...commonKeyValueDBFullSupport,
+  }
+
   // data[table][id] > Buffer
   data: StringMap<StringMap<Buffer>> = {}
 
@@ -21,6 +29,7 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
     ids.forEach(id => delete this.data[table]![id])
   }
 
+  // todo: but should we work with Tuples or Objects?
   async getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]> {
     this.data[table] ||= {}
     return ids.map(id => [id, this.data[table]![id]!] as KeyValueDBTuple).filter(e => e[1])
@@ -57,4 +66,19 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
 
     return newValue
   }
+
+  async incrementBatch(table: string, incrementMap: StringMap<number>): Promise<StringMap<number>> {
+    this.data[table] ||= {}
+
+    const result: StringMap<number> = {}
+
+    for (const [id, by] of _stringMapEntries(incrementMap)) {
+      const newValue = parseInt(this.data[table][id]?.toString() || '0') + by
+      // todo: but should this.data store Buffer or number for incremented values?
+      this.data[table][id] = Buffer.from(String(newValue))
+      result[id] = newValue
+    }
+
+    return result
+  }
 }

package/src/base.common.db.ts

@@ -1,11 +1,15 @@
-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'
@@ -50,12 +54,12 @@ export class BaseCommonDB implements CommonDB {
     throw new Error('deleteByQuery is not implemented')
   }
 
-  async updateByQuery<ROW extends ObjectWithId>(
+  async patchByQuery<ROW extends ObjectWithId>(
     _q: DBQuery<ROW>,
-    _patch: DBPatch<ROW>,
+    _patch: Partial<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<number> {
-    throw new Error('updateByQuery is not implemented')
+    throw new Error('patchByQuery is not implemented')
   }
 
   async runQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<RunQueryResult<ROW>> {
@@ -87,4 +91,13 @@ export class BaseCommonDB implements CommonDB {
     await fn(tx)
     // there's no try/catch and rollback, as there's nothing to rollback
   }
+
+  async incrementBatch(
+    _table: string,
+    _prop: string,
+    _incrementMap: StringMap<number>,
+    _opt?: CommonDBOptions,
+  ): Promise<StringMap<number>> {
+    throw new Error('incrementBatch is not implemented')
+  }
 }

package/src/common.db.ts

@@ -1,4 +1,9 @@
-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,
@@ -6,7 +11,6 @@ import {
   CommonDBSaveOptions,
   CommonDBStreamOptions,
   CommonDBTransactionOptions,
-  DBPatch,
   DBTransactionFn,
   RunQueryResult,
 } from './db.model'
@@ -28,23 +32,6 @@ export interface CommonDB {
    */
   support: CommonDBSupport
 
-  // Support flags indicate which of the CommonDB features are supported by this implementation.
-  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.
@@ -133,7 +120,7 @@ export interface CommonDB {
   ) => Promise<number>
 
   /**
-   * Applies patch to the rows returned by the query.
+   * Applies patch to all the rows that are matched by the query.
    *
    * Example:
    *
@@ -141,18 +128,11 @@ 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>(
+  patchByQuery: <ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    patch: DBPatch<ROW>,
+    patch: Partial<ROW>,
     opt?: CommonDBOptions,
   ) => Promise<number>
 
@@ -169,6 +149,28 @@ 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>>
 }
 
 /**
@@ -182,8 +184,8 @@ export interface CommonDBSupport {
   dbQuerySelectFields?: boolean
   insertSaveMethod?: boolean
   updateSaveMethod?: boolean
-  updateByQuery?: boolean
-  dbIncrement?: boolean
+  patchByQuery?: boolean
+  increment?: boolean
   createTable?: boolean
   tableSchemas?: boolean
   streaming?: boolean
@@ -200,8 +202,8 @@ export const commonDBFullSupport: CommonDBSupport = {
   dbQuerySelectFields: true,
   insertSaveMethod: true,
   updateSaveMethod: true,
-  updateByQuery: true,
-  dbIncrement: true,
+  patchByQuery: true,
+  increment: true,
   createTable: true,
   tableSchemas: true,
   streaming: true,