@naturalcycles/db-lib 10.0.2 → 10.1.0

package/src/pipeline/dbPipelineBackup.ts

@@ -13,8 +13,8 @@ import {
   transformTap,
   yellow,
 } from '@naturalcycles/nodejs-lib'
-import type { CommonDB } from '../common.db'
-import { DBQuery } from '../index'
+import type { CommonDB } from '../common.db.js'
+import { DBQuery } from '../query/dbQuery.js'
 
 export interface DBPipelineBackupOptions extends TransformLogProgressOptions {
   /**

package/src/pipeline/dbPipelineCopy.ts

@@ -14,9 +14,9 @@ import {
   writableForEach,
   yellow,
 } from '@naturalcycles/nodejs-lib'
-import type { CommonDB } from '../common.db'
-import type { CommonDBSaveOptions } from '../db.model'
-import { DBQuery } from '../query/dbQuery'
+import type { CommonDB } from '../common.db.js'
+import type { CommonDBSaveOptions } from '../db.model.js'
+import { DBQuery } from '../query/dbQuery.js'
 
 export interface DBPipelineCopyOptions extends TransformLogProgressOptions {
   dbInput: CommonDB

package/src/pipeline/dbPipelineRestore.ts

@@ -28,8 +28,8 @@ import {
   writableForEach,
   yellow,
 } from '@naturalcycles/nodejs-lib'
-import type { CommonDB } from '../common.db'
-import type { CommonDBSaveOptions } from '../index'
+import type { CommonDB } from '../common.db.js'
+import type { CommonDBSaveOptions } from '../db.model.js'
 
 export interface DBPipelineRestoreOptions extends TransformLogProgressOptions {
   /**

package/src/query/dbQuery.ts

@@ -1,15 +1,15 @@
 import type { AsyncMapper, BaseDBEntity, ObjectWithId } from '@naturalcycles/js-lib'
 import { _objectAssign, _truncate } from '@naturalcycles/js-lib'
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib'
+import type { CommonDao } from '../commondao/common.dao.js'
 import type {
   CommonDaoOptions,
   CommonDaoReadOptions,
   CommonDaoStreamDeleteOptions,
   CommonDaoStreamForEachOptions,
   CommonDaoStreamOptions,
-} from '..'
-import type { CommonDao } from '../commondao/common.dao'
-import type { RunQueryResult } from '../db.model'
+} from '../commondao/common.dao.model.js'
+import type { RunQueryResult } from '../db.model.js'
 
 /**
  * Modeled after Firestore operators (WhereFilterOp type)

package/src/testing/{dbTest.ts → commonDBTest.ts}

@@ -1,14 +1,14 @@
 import { _deepFreeze, _filterObject, _pick, _sortBy, localTime, pMap } from '@naturalcycles/js-lib'
-import type { CommonDB } from '../common.db'
-import { CommonDBType } from '../common.db'
-import { DBQuery } from '../query/dbQuery'
-import type { TestItemDBM } from './test.model'
+import type { CommonDB } from '../common.db.js'
+import { CommonDBType } from '../common.db.js'
+import { DBQuery } from '../query/dbQuery.js'
+import type { TestItemDBM } from './test.model.js'
 import {
   createTestItemDBM,
   createTestItemsDBM,
   TEST_TABLE,
   testItemBMJsonSchema,
-} from './test.model'
+} from './test.model.js'
 
 /**
  * All options default to `false`.
@@ -294,6 +294,18 @@ export async function runCommonDBTest(
   }
 
   if (support.transactions) {
+    /**
+     * Returns expected items in the DB after the preparation.
+     */
+    async function prepare(): Promise<TestItemDBM[]> {
+      // cleanup
+      await db.deleteByQuery(queryAll())
+
+      const itemsToSave: TestItemDBM[] = [items[0]!, { ...items[2]!, k1: 'k1_mod' }]
+      await db.saveBatch(TEST_TABLE, itemsToSave)
+      return itemsToSave
+    }
+
     test('transaction happy path', async () => {
       // cleanup
       await db.deleteByQuery(queryAll())
@@ -313,7 +325,24 @@ export async function runCommonDBTest(
       expectMatch(expected, rows, quirks)
     })
 
+    test('createTransaction happy path', async () => {
+      // cleanup
+      await db.deleteByQuery(queryAll())
+
+      const tx = await db.createTransaction()
+      await tx.saveBatch(TEST_TABLE, items)
+      await tx.saveBatch(TEST_TABLE, [{ ...items[2]!, k1: 'k1_mod' }])
+      await tx.deleteByIds(TEST_TABLE, [items[1]!.id])
+      await tx.commit()
+
+      const { rows } = await db.runQuery(queryAll())
+      const expected = [items[0], { ...items[2]!, k1: 'k1_mod' }]
+      expectMatch(expected, rows, quirks)
+    })
+
     test('transaction rollback', async () => {
+      const expected = await prepare()
+
       let err: any
 
       try {
@@ -329,7 +358,6 @@ export async function runCommonDBTest(
       expect(err).toBeDefined()
 
       const { rows } = await db.runQuery(queryAll())
-      const expected = [items[0], { ...items[2]!, k1: 'k1_mod' }]
       expectMatch(expected, rows, quirks)
     })
   }

package/src/testing/{daoTest.ts → commonDaoTest.ts}

@@ -1,18 +1,19 @@
 import { Readable } from 'node:stream'
 import { _deepCopy, _filterObject, _omit, _pick, _sortBy, localTime } from '@naturalcycles/js-lib'
 import { _pipeline } from '@naturalcycles/nodejs-lib'
-import { CommonDaoLogLevel, DBQuery } from '..'
-import type { CommonDB } from '../common.db'
-import { CommonDao } from '../commondao/common.dao'
-import type { TestItemBM } from '.'
-import type { CommonDBImplementationQuirks } from './dbTest'
+import type { CommonDB } from '../common.db.js'
+import { CommonDao } from '../commondao/common.dao.js'
+import { CommonDaoLogLevel } from '../commondao/common.dao.model.js'
+import { DBQuery } from '../query/dbQuery.js'
+import type { CommonDBImplementationQuirks } from './commonDBTest.js'
+import type { TestItemBM } from './test.model.js'
 import {
   createTestItemBM,
   createTestItemsBM,
   TEST_TABLE,
   testItemBMJsonSchema,
   testItemBMSchema,
-} from './test.model'
+} from './test.model.js'
 
 export async function runCommonDaoTest(
   db: CommonDB,
@@ -308,6 +309,18 @@ export async function runCommonDaoTest(
   }
 
   if (support.transactions) {
+    /**
+     * Returns expected items in the DB after the preparation.
+     */
+    async function prepare(): Promise<TestItemBM[]> {
+      // cleanup
+      await dao.query().deleteByQuery()
+
+      const itemsToSave: TestItemBM[] = [items[0]!, { ...items[2]!, k1: 'k1_mod' }]
+      await dao.saveBatch(itemsToSave)
+      return itemsToSave
+    }
+
     test('transaction happy path', async () => {
       // cleanup
       await dao.query().deleteByQuery()
@@ -345,16 +358,81 @@ export async function runCommonDaoTest(
       expectMatch(expected, rows, quirks)
     })
 
+    test('createTransaction happy path', async () => {
+      // cleanup
+      await dao.query().deleteByQuery()
+
+      // Test that id, created, updated are created
+      const now = localTime.nowUnix()
+
+      const row = _omit(item1, ['id', 'created', 'updated'])
+      let tx = await dao.createTransaction()
+      await tx.save(dao, row)
+      await tx.commit()
+
+      const loaded = await dao.query().runQuery()
+      expect(loaded.length).toBe(1)
+      expect(loaded[0]!.id).toBeDefined()
+      expect(loaded[0]!.created).toBeGreaterThanOrEqual(now)
+      expect(loaded[0]!.updated).toBe(loaded[0]!.created)
+
+      tx = await dao.createTransaction()
+      await tx.deleteById(dao, loaded[0]!.id)
+      await tx.commit()
+
+      // saveBatch [item1, 2, 3]
+      // save item3 with k1: k1_mod
+      // delete item2
+      // remaining: item1, item3_with_k1_mod
+      tx = await dao.createTransaction()
+      await tx.saveBatch(dao, items)
+      await tx.save(dao, { ...items[2]!, k1: 'k1_mod' })
+      await tx.deleteById(dao, items[1]!.id)
+      await tx.commit()
+
+      const rows = await dao.query().runQuery()
+      const expected = [items[0], { ...items[2]!, k1: 'k1_mod' }]
+      expectMatch(expected, rows, quirks)
+    })
+
     test('transaction rollback', async () => {
-      await expect(
-        dao.runInTransaction(async tx => {
+      const expected = await prepare()
+
+      let err: any
+
+      try {
+        await 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
-        }),
-      ).rejects.toThrow()
+        })
+      } catch (err_) {
+        err = err_
+      }
+
+      expect(err).toBeDefined()
+      expect(err).toBeInstanceOf(Error)
+
+      const rows = await dao.query().runQuery()
+      expectMatch(expected, rows, quirks)
+    })
+
+    test('createTransaction rollback', async () => {
+      const expected = await prepare()
+
+      let err: any
+      try {
+        const tx = await dao.createTransaction()
+        await tx.deleteById(dao, items[2]!.id)
+        await tx.save(dao, { ...items[0]!, k1: 5 as any }) // it should fail here
+        await tx.commit()
+      } catch (err_) {
+        err = err_
+      }
+
+      expect(err).toBeDefined()
+      expect(err).toBeInstanceOf(Error)
 
       const rows = await dao.query().runQuery()
-      const expected = [items[0], { ...items[2]!, k1: 'k1_mod' }]
       expectMatch(expected, rows, quirks)
     })
 

package/src/testing/index.ts

@@ -1,9 +1,9 @@
-import { runCommonDaoTest } from './daoTest'
-import type { CommonDBImplementationQuirks } from './dbTest'
-import { runCommonDBTest } from './dbTest'
-import { runCommonKeyValueDaoTest } from './keyValueDaoTest'
-import { runCommonKeyValueDBTest } from './keyValueDBTest'
-import type { TestItemBM, TestItemDBM, TestItemTM } from './test.model'
+import { runCommonDaoTest } from './commonDaoTest.js'
+import type { CommonDBImplementationQuirks } from './commonDBTest.js'
+import { runCommonDBTest } from './commonDBTest.js'
+import { runCommonKeyValueDaoTest } from './keyValueDaoTest.js'
+import { runCommonKeyValueDBTest } from './keyValueDBTest.js'
+import type { TestItemBM, TestItemDBM, TestItemTM } from './test.model.js'
 import {
   createTestItemBM,
   createTestItemDBM,
@@ -13,7 +13,7 @@ import {
   testItemBMJsonSchema,
   testItemBMSchema,
   testItemTMSchema,
-} from './test.model'
+} from './test.model.js'
 
 export type { CommonDBImplementationQuirks, TestItemBM, TestItemDBM, TestItemTM }
 

package/src/testing/keyValueDBTest.ts

@@ -1,7 +1,7 @@
 import type { KeyValueTuple } from '@naturalcycles/js-lib'
 import { _range, _sortBy } from '@naturalcycles/js-lib'
-import type { CommonKeyValueDB } from '../kv/commonKeyValueDB'
-import { TEST_TABLE } from './test.model'
+import type { CommonKeyValueDB } from '../kv/commonKeyValueDB.js'
+import { TEST_TABLE } from './test.model.js'
 
 const testIds = _range(1, 4).map(n => `id${n}`)
 

package/src/testing/keyValueDaoTest.ts

@@ -1,7 +1,7 @@
 import { _sortBy } from '@naturalcycles/js-lib'
-import { CommonKeyValueDao } from '../kv/commonKeyValueDao'
-import type { CommonKeyValueDB, KeyValueDBTuple } from '../kv/commonKeyValueDB'
-import { createTestItemsBM, TEST_TABLE } from './test.model'
+import { CommonKeyValueDao } from '../kv/commonKeyValueDao.js'
+import type { CommonKeyValueDB, KeyValueDBTuple } from '../kv/commonKeyValueDB.js'
+import { createTestItemsBM, TEST_TABLE } from './test.model.js'
 
 const testItems = createTestItemsBM(4)
 const testIds = testItems.map(e => e.id)

package/src/testing/timeSeriesTest.util.ts

@@ -1,5 +1,5 @@
 import { _randomInt, _range } from '@naturalcycles/js-lib'
-import type { TimeSeriesDataPoint } from '../timeseries/timeSeries.model'
+import type { TimeSeriesDataPoint } from '../timeseries/timeSeries.model.js'
 
 export function createTestTimeSeries(count = 10): TimeSeriesDataPoint[] {
   const ts = Date.now()

package/src/timeseries/commonTimeSeriesDao.ts

@@ -1,13 +1,13 @@
 import type { ObjectWithId } from '@naturalcycles/js-lib'
 import { _isTruthy } from '@naturalcycles/js-lib'
-import { DBQuery } from '../query/dbQuery'
+import { DBQuery } from '../query/dbQuery.js'
 import type {
   CommonTimeSeriesDaoCfg,
   TimeSeriesDataPoint,
   TimeSeriesQuery,
   TimeSeriesRow,
   TimeSeriesSaveBatchOp,
-} from './timeSeries.model'
+} from './timeSeries.model.js'
 
 const _TIMESERIES_RAW = '_TIMESERIES_RAW'
 

package/src/timeseries/timeSeries.model.ts

@@ -1,4 +1,4 @@
-import type { CommonDB } from '../common.db'
+import type { CommonDB } from '../common.db.js'
 
 export interface CommonTimeSeriesDaoCfg {
   db: CommonDB

package/src/transaction/dbTransaction.util.ts

@@ -1,6 +1,6 @@
 import type { ObjectWithId } from '@naturalcycles/js-lib'
-import type { CommonDB } from '../common.db'
-import type { CommonDBOptions, CommonDBSaveOptions, DBTransaction } from '../db.model'
+import type { CommonDB } from '../common.db.js'
+import type { CommonDBOptions, CommonDBSaveOptions, DBTransaction } from '../db.model.js'
 
 /**
  * Optimizes the Transaction (list of DBOperations) to do less operations.
@@ -98,6 +98,7 @@ export class FakeDBTransaction implements DBTransaction {
   constructor(protected db: CommonDB) {}
 
   // no-op
+  async commit(): Promise<void> {}
   async rollback(): Promise<void> {}
 
   async getByIds<ROW extends ObjectWithId>(

package/src/validation/index.ts

@@ -7,9 +7,14 @@ import {
   objectSchema,
   stringSchema,
 } from '@naturalcycles/nodejs-lib'
-import type { CommonDBOptions, CommonDBSaveOptions } from '../db.model'
-import type { DBQuery, DBQueryFilter, DBQueryFilterOperator, DBQueryOrder } from '../query/dbQuery'
-import { dbQueryFilterOperatorValues } from '../query/dbQuery'
+import type { CommonDBOptions, CommonDBSaveOptions } from '../db.model.js'
+import type {
+  DBQuery,
+  DBQueryFilter,
+  DBQueryFilterOperator,
+  DBQueryOrder,
+} from '../query/dbQuery.js'
+import { dbQueryFilterOperatorValues } from '../query/dbQuery.js'
 
 export const commonDBOptionsSchema = objectSchema<CommonDBOptions>({
   ['onlyCache' as any]: booleanSchema.optional(),

package/dist/testing/daoTest.d.ts

@@ -1,3 +0,0 @@
-import type { CommonDB } from '../common.db';
-import type { CommonDBImplementationQuirks } from './dbTest';
-export declare function runCommonDaoTest(db: CommonDB, quirks?: CommonDBImplementationQuirks): Promise<void>;