@naturalcycles/db-lib 9.0.0 → 9.1.1

package/src/testing/daoTest.ts

@@ -265,7 +265,7 @@ export function runCommonDaoTest(db: CommonDB, quirks: CommonDBImplementationQui
       // Test that id, created, updated are created
       const now = localTimeNow().unix()
 
-      await dao.useTransaction(async tx => {
+      await dao.runInTransaction(async tx => {
         const row = _omit(item1, ['id', 'created', 'updated'])
         await tx.save(dao, row)
       })
@@ -276,7 +276,7 @@ export function runCommonDaoTest(db: CommonDB, quirks: CommonDBImplementationQui
       expect(loaded[0]!.created).toBeGreaterThanOrEqual(now)
       expect(loaded[0]!.updated).toBe(loaded[0]!.created)
 
-      await dao.useTransaction(async tx => {
+      await dao.runInTransaction(async tx => {
         await tx.deleteById(dao, loaded[0]!.id)
       })
 
@@ -284,7 +284,7 @@ export function runCommonDaoTest(db: CommonDB, quirks: CommonDBImplementationQui
       // save item3 with k1: k1_mod
       // delete item2
       // remaining: item1, item3_with_k1_mod
-      await dao.useTransaction(async tx => {
+      await dao.runInTransaction(async tx => {
         await tx.saveBatch(dao, items)
         await tx.save(dao, { ...items[2]!, k1: 'k1_mod' })
         await tx.deleteById(dao, items[1]!.id)
@@ -297,7 +297,7 @@ export function runCommonDaoTest(db: CommonDB, quirks: CommonDBImplementationQui
 
     test('transaction rollback', async () => {
       await expect(
-        dao.useTransaction(async tx => {
+        dao.runInTransaction(async tx => {
           await tx.deleteById(dao, items[2]!.id)
           await tx.save(dao, { ...items[0]!, k1: 5 as any }) // it should fail here
         }),

package/src/testing/dbTest.ts

@@ -287,11 +287,11 @@ export function runCommonDBTest(db: CommonDB, quirks: CommonDBImplementationQuir
       // save item3 with k1: k1_mod
       // delete item2
       // remaining: item1, item3_with_k1_mod
-      const tx = await db.createTransaction()
-      await db.saveBatch(TEST_TABLE, items, { tx })
-      await db.saveBatch(TEST_TABLE, [{ ...items[2]!, k1: 'k1_mod' }], { tx })
-      await db.deleteByIds(TEST_TABLE, [items[1]!.id], { tx })
-      await tx.commit()
+      await db.runInTransaction(async tx => {
+        await tx.saveBatch(TEST_TABLE, items)
+        await tx.saveBatch(TEST_TABLE, [{ ...items[2]!, k1: 'k1_mod' }])
+        await tx.deleteByIds(TEST_TABLE, [items[1]!.id])
+      })
 
       const { rows } = await db.runQuery(queryAll())
       const expected = [items[0], { ...items[2]!, k1: 'k1_mod' }]
@@ -299,14 +299,14 @@ export function runCommonDBTest(db: CommonDB, quirks: CommonDBImplementationQuir
     })
 
     test('transaction rollback', async () => {
-      // It should fail on id == null
       let err: any
 
       try {
-        const tx = await db.createTransaction()
-        await db.deleteByIds(TEST_TABLE, [items[2]!.id], { tx })
-        await db.saveBatch(TEST_TABLE, [{ ...items[0]!, k1: 5, id: null as any }], { tx })
-        await tx.commit()
+        await db.runInTransaction(async tx => {
+          await tx.deleteByIds(TEST_TABLE, [items[2]!.id])
+          // It should fail on id == null
+          await tx.saveBatch(TEST_TABLE, [{ ...items[0]!, k1: 5, id: null as any }])
+        })
       } catch (err_) {
         err = err_
       }

package/src/timeseries/commonTimeSeriesDao.ts

@@ -52,19 +52,17 @@ export class CommonTimeSeriesDao {
   async commitTransaction(ops: TimeSeriesSaveBatchOp[]): Promise<void> {
     if (!ops.length) return
 
-    const tx = await this.cfg.db.createTransaction()
-
-    for (const op of ops) {
-      const rows: ObjectWithId[] = op.dataPoints.map(([ts, v]) => ({
-        id: String(ts), // Convert Number id into String id, as per CommonDB
-        ts, // to allow querying by ts, since querying by id is not always available (Datastore is one example)
-        v,
-      }))
-
-      await this.cfg.db.saveBatch(`${op.series}${_TIMESERIES_RAW}`, rows, { tx })
-    }
-
-    await tx.commit()
+    await this.cfg.db.runInTransaction(async tx => {
+      for (const op of ops) {
+        const rows: ObjectWithId[] = op.dataPoints.map(([ts, v]) => ({
+          id: String(ts), // Convert Number id into String id, as per CommonDB
+          ts, // to allow querying by ts, since querying by id is not always available (Datastore is one example)
+          v,
+        }))
+
+        await tx.saveBatch(`${op.series}${_TIMESERIES_RAW}`, rows)
+      }
+    })
   }
 
   async deleteById(series: string, tsMillis: number): Promise<void> {

package/src/transaction/dbTransaction.util.ts

@@ -1,7 +1,6 @@
 import { ObjectWithId } from '@naturalcycles/js-lib'
 import type { CommonDB } from '../common.db'
-import { CommonDBOptions, CommonDBSaveOptions, DBTransaction, RunQueryResult } from '../db.model'
-import { DBQuery } from '../query/dbQuery'
+import { CommonDBOptions, CommonDBSaveOptions, DBTransaction } from '../db.model'
 
 /**
  * Optimizes the Transaction (list of DBOperations) to do less operations.
@@ -98,7 +97,7 @@ export function mergeDBOperations(ops: DBOperation[]): DBOperation[] {
 export class FakeDBTransaction implements DBTransaction {
   constructor(protected db: CommonDB) {}
 
-  async commit(): Promise<void> {}
+  // no-op
   async rollback(): Promise<void> {}
 
   async getByIds<ROW extends ObjectWithId>(
@@ -108,18 +107,18 @@ export class FakeDBTransaction implements DBTransaction {
   ): Promise<ROW[]> {
     return await this.db.getByIds(table, ids, opt)
   }
-  async runQuery<ROW extends ObjectWithId>(
-    q: DBQuery<ROW>,
-    opt?: CommonDBOptions,
-  ): Promise<RunQueryResult<ROW>> {
-    return await this.db.runQuery(q, opt)
-  }
+  // async runQuery<ROW extends ObjectWithId>(
+  //   q: DBQuery<ROW>,
+  //   opt?: CommonDBOptions,
+  // ): Promise<RunQueryResult<ROW>> {
+  //   return await this.db.runQuery(q, opt)
+  // }
   async saveBatch<ROW extends Partial<ObjectWithId>>(
     table: string,
     rows: ROW[],
     opt?: CommonDBSaveOptions<ROW>,
   ): Promise<void> {
-    return await this.db.saveBatch(table, rows, opt)
+    await this.db.saveBatch(table, rows, opt)
   }
   async deleteByIds(
     table: string,