@naturalcycles/db-lib 9.21.0 → 9.22.1

package/src/query/dbQuery.ts

@@ -11,7 +11,6 @@ import {
   CommonDaoStreamDeleteOptions,
   CommonDaoStreamForEachOptions,
   CommonDaoStreamOptions,
-  DBPatch,
 } from '..'
 import { CommonDao } from '../commondao/common.dao'
 import { RunQueryResult } from '../db.model'
@@ -276,8 +275,8 @@ export class RunnableDBQuery<
     return await this.dao.runQueryCount(this, opt)
   }
 
-  async updateByQuery(patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number> {
-    return await this.dao.updateByQuery(this, patch, opt)
+  async patchByQuery(patch: Partial<DBM>, opt?: CommonDaoOptions): Promise<number> {
+    return await this.dao.patchByQuery(this, patch, opt)
   }
 
   async streamQueryForEach(

package/src/testing/daoTest.ts

@@ -129,6 +129,34 @@ export function runCommonDaoTest(db: CommonDB, quirks: CommonDBImplementationQui
     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 = _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
+      })
+      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/src/testing/dbTest.ts

@@ -1,6 +1,5 @@
 import { _deepFreeze, _filterObject, _pick, _sortBy, pMap } from '@naturalcycles/js-lib'
 import { CommonDB, CommonDBType } from '../common.db'
-import { DBIncrement, DBPatch } from '../db.model'
 import { DBQuery } from '../query/dbQuery'
 import {
   createTestItemDBM,
@@ -317,18 +316,18 @@ export function runCommonDBTest(db: CommonDB, quirks: CommonDBImplementationQuir
     })
   }
 
-  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_TABLE, items)
 
-      const patch: DBPatch<TestItemDBM> = {
+      const patch: Partial<TestItemDBM> = {
         k3: 5,
         k2: 'abc',
       }
 
-      await db.updateByQuery(DBQuery.create<TestItemDBM>(TEST_TABLE).filterEq('even', true), patch)
+      await db.patchByQuery(DBQuery.create<TestItemDBM>(TEST_TABLE).filterEq('even', true), patch)
 
       const { rows } = await db.runQuery(queryAll())
       const expected = items.map(r => {
@@ -339,33 +338,28 @@ export function runCommonDBTest(db: CommonDB, quirks: CommonDBImplementationQuir
       })
       expectMatch(expected, rows, quirks)
     })
+  }
 
-    if (support.dbIncrement) {
-      test('updateByQuery DBIncrement', async () => {
-        // cleanup, reset initial data
-        await db.deleteByQuery(queryAll())
-        await db.saveBatch(TEST_TABLE, items)
-
-        const patch: DBPatch<TestItemDBM> = {
-          k3: DBIncrement.of(1),
-          k2: 'abcd',
-        }
+  if (support.increment) {
+    test('incrementBatch', async () => {
+      // cleanup, reset initial data
+      await db.deleteByQuery(queryAll())
+      await db.saveBatch(TEST_TABLE, items)
 
-        await db.updateByQuery(
-          DBQuery.create<TestItemDBM>(TEST_TABLE).filterEq('even', true),
-          patch,
-        )
+      await db.incrementBatch(TEST_TABLE, 'k3', { id1: 1, id2: 2 })
 
-        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)
+      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) {

package/src/testing/keyValueDBTest.ts

@@ -1,10 +1,13 @@
-import { _range, _sortBy } from '@naturalcycles/js-lib'
-import { CommonKeyValueDB, KeyValueDBTuple } from '../kv/commonKeyValueDB'
+import { _range, _sortBy, KeyValueTuple } from '@naturalcycles/js-lib'
+import { CommonKeyValueDB } from '../kv/commonKeyValueDB'
 import { TEST_TABLE } from './test.model'
 
 const testIds = _range(1, 4).map(n => `id${n}`)
 
-const testEntries: KeyValueDBTuple[] = testIds.map(id => [id, Buffer.from(`${id}value`)])
+const testEntries: KeyValueTuple<string, Buffer>[] = testIds.map(id => [
+  id,
+  Buffer.from(`${id}value`),
+])
 
 export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
   beforeAll(async () => {
@@ -47,7 +50,7 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
   test('saveBatch, then getByIds', async () => {
     await db.saveBatch(TEST_TABLE, testEntries)
 
-    const entries = await db.getByIds(TEST_TABLE, testIds)
+    const entries = await db.getByIds<Buffer>(TEST_TABLE, testIds)
     _sortBy(entries, e => e[0], true)
     expect(entries).toEqual(testEntries)
   })
@@ -73,26 +76,26 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
   })
 
   test('streamValues', async () => {
-    const values = await db.streamValues(TEST_TABLE).toArray()
+    const values = await db.streamValues<Buffer>(TEST_TABLE).toArray()
     values.sort()
     expect(values).toEqual(testEntries.map(e => e[1]))
   })
 
   test('streamValues limited', async () => {
-    const valuesLimited = await db.streamValues(TEST_TABLE, 2).toArray()
+    const valuesLimited = await db.streamValues<Buffer>(TEST_TABLE, 2).toArray()
     // valuesLimited.sort()
     // expect(valuesLimited).toEqual(testEntries.map(e => e[1]).slice(0, 2))
     expect(valuesLimited.length).toBe(2)
   })
 
   test('streamEntries', async () => {
-    const entries = await db.streamEntries(TEST_TABLE).toArray()
+    const entries = await db.streamEntries<Buffer>(TEST_TABLE).toArray()
     entries.sort()
     expect(entries).toEqual(testEntries)
   })
 
   test('streamEntries limited', async () => {
-    const entriesLimited = await db.streamEntries(TEST_TABLE, 2).toArray()
+    const entriesLimited = await db.streamEntries<Buffer>(TEST_TABLE, 2).toArray()
     // entriesLimited.sort()
     // expect(entriesLimited).toEqual(testEntries.slice(0, 2))
     expect(entriesLimited.length).toBe(2)
@@ -105,19 +108,33 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
   })
 
   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_TABLE, 'nonExistingField')
-      expect(result).toBe(1)
+      const result = await db.incrementBatch(TEST_TABLE, [[id, 1]])
+      expect(result).toEqual([[id, 1]])
     })
 
     test('increment on a existing field should increase the value by one', async () => {
-      const result = await db.increment(TEST_TABLE, 'nonExistingField')
-      expect(result).toBe(2)
+      const result = await db.incrementBatch(TEST_TABLE, [[id, 1]])
+      expect(result).toEqual([[id, 2]])
     })
 
     test('increment should increase the value by the specified amount', async () => {
-      const result = await db.increment(TEST_TABLE, 'nonExistingField', 2)
-      expect(result).toBe(4)
+      const result = await db.incrementBatch(TEST_TABLE, [[id, 2]])
+      expect(result).toEqual([[id, 4]])
+    })
+
+    test('increment 2 ids at the same time', async () => {
+      const result = await db.incrementBatch(TEST_TABLE, [
+        [id, 1],
+        [id2, 2],
+      ])
+      expect(Object.fromEntries(result)).toEqual({
+        [id]: 5,
+        [id2]: 2,
+      })
     })
   }
 }

package/src/testing/keyValueDaoTest.ts

@@ -1,11 +1,20 @@
-import { _range, _sortBy } from '@naturalcycles/js-lib'
+import { _sortBy, KeyValueTuple } from '@naturalcycles/js-lib'
 import { CommonKeyValueDao } from '../kv/commonKeyValueDao'
-import { KeyValueDBTuple } from '../kv/commonKeyValueDB'
-
-const testIds = _range(1, 4).map(n => `id${n}`)
-const testEntries: KeyValueDBTuple[] = testIds.map(id => [id, Buffer.from(`${id}value`)])
+import { CommonKeyValueDB } from '../kv/commonKeyValueDB'
+import { createTestItemsBM, TEST_TABLE, TestItemBM } from './test.model'
+
+const testItems = createTestItemsBM(4)
+const testIds = testItems.map(e => e.id)
+const testEntries: KeyValueTuple<string, TestItemBM>[] = testItems.map(e => [e.id, e])
+
+export function runCommonKeyValueDaoTest(db: CommonKeyValueDB): void {
+  const dao = new CommonKeyValueDao<string, TestItemBM>({
+    db,
+    table: TEST_TABLE,
+    // todo: make this test support "deflatedJson" transformer
+  })
+  const { support } = db
 
-export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
   beforeAll(async () => {
     // Tests in this suite are not isolated,
     // and failing tests can leave the DB in an unexpected state for other tests,
@@ -20,8 +29,6 @@ export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
     await dao.deleteByIds(ids)
   })
 
-  const { support } = dao.cfg.db
-
   test('ping', async () => {
     await dao.ping()
   })
@@ -43,8 +50,12 @@ export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
     await dao.saveBatch(testEntries)
 
     const entries = await dao.getByIds(testIds)
+    // console.log(typeof entries[0]![1], entries[0]![1])
+
     _sortBy(entries, e => e[0], true)
-    expect(entries).toEqual(testEntries)
+    expect(entries).toEqual(testEntries) // Jest doesn't allow to compare Buffers directly
+    // expect(entries.map(e => e[0])).toEqual(testEntries.map(e => e[0]))
+    // expect(entries.map(e => e[1].toString())).toEqual(testEntries.map(e => e[1].toString()))
   })
 
   test('streamIds', async () => {
@@ -94,19 +105,33 @@ export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
   })
 
   if (support.increment) {
+    const id = 'nonExistingField'
+    const id2 = 'nonExistingField2'
+
     test('increment on a non-existing field should set the value to 1', async () => {
-      const result = await dao.increment('nonExistingField')
+      const result = await dao.increment(id)
       expect(result).toBe(1)
     })
 
     test('increment on a existing field should increase the value by one', async () => {
-      const result = await dao.increment('nonExistingField')
+      const result = await dao.increment(id)
       expect(result).toBe(2)
     })
 
     test('increment should increase the value by the specified amount', async () => {
-      const result = await dao.increment('nonExistingField', 2)
+      const result = await dao.increment(id, 2)
       expect(result).toBe(4)
     })
+
+    test('increment 2 ids at the same time', async () => {
+      const result = await dao.incrementBatch([
+        [id, 1],
+        [id2, 2],
+      ])
+      expect(Object.fromEntries(result)).toEqual({
+        [id]: 5,
+        [id2]: 2,
+      })
+    })
   }
 }