@naturalcycles/db-lib 8.41.0 → 8.42.0

package/src/testing/dbTest.ts

@@ -2,6 +2,7 @@ import { pDelay, pMap, _filterObject, _pick, _sortBy } from '@naturalcycles/js-l
 import { readableToArray } from '@naturalcycles/nodejs-lib'
 import { CommonDB } from '../common.db'
 import { DBQuery } from '../query/dbQuery'
+import { DBTransaction } from '../transaction/dbTransaction'
 import {
   createTestItemDBM,
   createTestItemsDBM,
@@ -43,6 +44,8 @@ export interface CommonDBImplementationFeatures {
    * they will return `null` for all missing properties.
    */
   documentDB?: boolean
+
+  transactions?: boolean
 }
 
 /**
@@ -89,6 +92,7 @@ export function runCommonDBTest(
     bufferSupport = true,
     nullValues = true,
     documentDB = true,
+    transactions = true,
   } = features
 
   // const {
@@ -190,6 +194,10 @@ export function runCommonDBTest(
     await db.saveBatch(TEST_TABLE, items)
   })
 
+  test('saveBatch should throw on null id', async () => {
+    await expect(db.saveBatch(TEST_TABLE, [{ ...item1, id: null as any }])).rejects.toThrow()
+  })
+
   if (insert) {
     test('saveBatch INSERT method should throw', async () => {
       await expect(db.saveBatch(TEST_TABLE, items, { saveMethod: 'insert' })).rejects.toThrow()
@@ -290,12 +298,12 @@ export function runCommonDBTest(
   // getTables
   test('getTables, getTableSchema (if supported)', async () => {
     const tables = await db.getTables()
-    console.log({ tables })
+    // console.log({ tables })
 
     if (tableSchemas) {
       await pMap(tables, async table => {
         const schema = await db.getTableSchema(table)
-        console.log(schema)
+        // console.log(schema)
         expect(schema.$id).toBe(`${table}.schema.json`)
       })
     }
@@ -327,19 +335,54 @@ export function runCommonDBTest(
       await db.saveBatch(TEST_TABLE, [item])
       const [loaded] = await db.getByIds<TestItemDBM>(TEST_TABLE, [item.id])
       const b1Loaded = loaded!.b1!
-      console.log({
-        b11: typeof b1,
-        b12: typeof b1Loaded,
-        l1: b1.length,
-        l2: b1Loaded.length,
-        b1,
-        b1Loaded,
-      })
+      // console.log({
+      //   b11: typeof b1,
+      //   b12: typeof b1Loaded,
+      //   l1: b1.length,
+      //   l2: b1Loaded.length,
+      //   b1,
+      //   b1Loaded,
+      // })
       expect(b1Loaded).toEqual(b1)
       expect(b1Loaded.toString()).toBe(s)
     })
   }
 
+  if (transactions) {
+    test('transaction happy path', async () => {
+      // cleanup
+      await db.deleteByQuery(queryAll())
+
+      // saveBatch [item1, 2, 3]
+      // save item3 with k1: k1_mod
+      // delete item2
+      // remaining: item1, item3_with_k1_mod
+      const tx = DBTransaction.create()
+        .saveBatch(TEST_TABLE, items)
+        .save(TEST_TABLE, { ...items[2]!, k1: 'k1_mod' })
+        .deleteById(TEST_TABLE, items[1]!.id)
+
+      await db.commitTransaction(tx)
+
+      const { rows } = await db.runQuery(queryAll())
+      const expected = [items[0], { ...items[2]!, k1: 'k1_mod' }]
+      expectMatch(expected, rows, quirks)
+    })
+
+    test('transaction rollback', async () => {
+      // It should fail on id == null
+      const tx = DBTransaction.create()
+        .deleteById(TEST_TABLE, items[2]!.id)
+        .save(TEST_TABLE, { ...items[0]!, k1: 5, id: null as any })
+
+      await expect(db.commitTransaction(tx)).rejects.toThrow()
+
+      const { rows } = await db.runQuery(queryAll())
+      const expected = [items[0], { ...items[2]!, k1: 'k1_mod' }]
+      expectMatch(expected, rows, quirks)
+    })
+  }
+
   if (querying) {
     test('cleanup', async () => {
       // CLEAN UP

package/src/timeseries/commonTimeSeriesDao.ts

@@ -53,7 +53,7 @@ export class CommonTimeSeriesDao {
   async commitTransaction(ops: TimeSeriesSaveBatchOp[]): Promise<void> {
     if (!ops.length) return
 
-    const tx = new DBTransaction()
+    const tx = DBTransaction.create()
 
     ops.forEach(op => {
       const rows: ObjectWithId[] = op.dataPoints.map(([ts, v]) => ({

package/src/transaction/dbTransaction.ts

@@ -6,7 +6,23 @@ import type { CommonDBSaveOptions, DBOperation } from '../db.model'
  * Convenience class that stores the list of DBOperations and provides a fluent API to add them.
  */
 export class DBTransaction {
-  public ops: DBOperation[] = []
+  protected constructor(public ops: DBOperation[] = []) {}
+
+  /**
+   * Convenience method.
+   */
+  static create(ops: DBOperation[] = []): DBTransaction {
+    return new DBTransaction(ops)
+  }
+
+  save<ROW extends ObjectWithId = AnyObjectWithId>(table: string, row: ROW): this {
+    this.ops.push({
+      type: 'saveBatch',
+      table,
+      rows: [row],
+    })
+    return this
+  }
 
   saveBatch<ROW extends ObjectWithId = AnyObjectWithId>(table: string, rows: ROW[]): this {
     this.ops.push({
@@ -17,6 +33,15 @@ export class DBTransaction {
     return this
   }
 
+  deleteById(table: string, id: string): this {
+    this.ops.push({
+      type: 'deleteByIds',
+      table,
+      ids: [id],
+    })
+    return this
+  }
+
   deleteByIds(table: string, ids: string[]): this {
     this.ops.push({
       type: 'deleteByIds',

package/src/transaction/dbTransaction.util.ts

@@ -1,30 +1,32 @@
-import { StringMap, _stringMapEntries, ObjectWithId } from '@naturalcycles/js-lib'
 import type { CommonDB } from '../common.db'
-import { CommonDBSaveOptions, DBOperation } from '../db.model'
+import { CommonDBSaveOptions } from '../db.model'
 import { DBTransaction } from './dbTransaction'
 
 /**
  * Optimizes the Transaction (list of DBOperations) to do less operations.
  * E.g if you save id1 first and then delete it - this function will turn it into a no-op (self-eliminate).
+ * UPD: actually, it will only keep delete, but remove previous ops.
  *
  * Currently only takes into account SaveBatch and DeleteByIds ops.
- * Output ops are maximum 2 (per table) - save and delete (where order actually doesn't matter, cause ids there will not overlap).
+ * Output ops are maximum 1 per entity - save or delete.
  */
+// Commented out as "overly complicated"
+/*
 export function mergeDBOperations(ops: DBOperation[]): DBOperation[] {
   if (ops.length <= 1) return ops // nothing to optimize there
 
   // This map will be saved in the end. Null would mean "delete"
   // saveMap[table][id] => row
-  const saveMapByTable: StringMap<StringMap<ObjectWithId | null>> = {}
+  const data: StringMap<StringMap<ObjectWithId | null>> = {}
 
   // Merge ops using `saveMap`
   ops.forEach(op => {
-    saveMapByTable[op.table] = saveMapByTable[op.table] || {}
+    data[op.table] ||= {}
 
     if (op.type === 'saveBatch') {
-      op.rows.forEach(r => (saveMapByTable[op.table]![r.id] = r))
+      op.rows.forEach(r => (data[op.table]![r.id] = r))
     } else if (op.type === 'deleteByIds') {
-      op.ids.forEach(id => (saveMapByTable[op.table]![id] = null))
+      op.ids.forEach(id => (data[op.table]![id] = null))
     } else {
       throw new Error(`DBOperation not supported: ${(op as any).type}`)
     }
@@ -32,37 +34,31 @@ export function mergeDBOperations(ops: DBOperation[]): DBOperation[] {
 
   const resultOps: DBOperation[] = []
 
-  _stringMapEntries(saveMapByTable).forEach(([table, saveMap]) => {
-    const rowsToSave: ObjectWithId[] = []
-    const idsToDelete: string[] = []
+  _stringMapEntries(data).forEach(([table, map]) => {
+    const saveOp: DBSaveBatchOperation = {
+      type: 'saveBatch',
+      table,
+      rows: _stringMapValues(map).filter(_isTruthy),
+    }
 
-    _stringMapEntries(saveMap).forEach(([id, r]) => {
-      if (r === null) {
-        idsToDelete.push(id)
-      } else {
-        rowsToSave.push(r)
-      }
-    })
+    if (saveOp.rows.length) {
+      resultOps.push(saveOp)
+    }
 
-    if (rowsToSave.length) {
-      resultOps.push({
-        type: 'saveBatch',
-        table,
-        rows: rowsToSave,
-      })
+    const deleteOp: DBDeleteByIdsOperation = {
+      type: 'deleteByIds',
+      table,
+      ids: _stringMapEntries(map).filter(([id, row]) => row === null).map(([id]) => id),
     }
 
-    if (idsToDelete.length) {
-      resultOps.push({
-        type: 'deleteByIds',
-        table,
-        ids: idsToDelete,
-      })
+    if (deleteOp.ids.length) {
+      resultOps.push(deleteOp)
     }
   })
 
   return resultOps
 }
+ */
 
 /**
  * Naive implementation of "Transaction" which just executes all operations one-by-one.
@@ -74,13 +70,13 @@ export async function commitDBTransactionSimple(
   tx: DBTransaction,
   opt?: CommonDBSaveOptions,
 ): Promise<void> {
-  const ops = mergeDBOperations(tx.ops)
+  // const ops = mergeDBOperations(tx.ops)
 
-  for await (const op of ops) {
+  for await (const op of tx.ops) {
     if (op.type === 'saveBatch') {
-      await db.saveBatch(op.table, op.rows, opt)
+      await db.saveBatch(op.table, op.rows, { ...op.opt, ...opt })
     } else if (op.type === 'deleteByIds') {
-      await db.deleteByIds(op.table, op.ids, opt)
+      await db.deleteByIds(op.table, op.ids, { ...op.opt, ...opt })
     } else {
       throw new Error(`DBOperation not supported: ${(op as any).type}`)
     }