@naturalcycles/db-lib 10.26.1 → 10.28.0

package/src/pipeline/dbPipelineRestore.ts

@@ -9,11 +9,11 @@ import { _passthroughMapper } from '@naturalcycles/js-lib/types'
 import { boldWhite, dimWhite, grey, yellow } from '@naturalcycles/nodejs-lib/colors'
 import { fs2 } from '@naturalcycles/nodejs-lib/fs2'
 import {
+  NDJsonStats,
   Pipeline,
   type TransformLogProgressOptions,
   type TransformMapOptions,
 } from '@naturalcycles/nodejs-lib/stream'
-import { NDJsonStats } from '@naturalcycles/nodejs-lib/stream'
 import type { CommonDB } from '../commondb/common.db.js'
 import type { CommonDBSaveOptions } from '../db.model.js'
 
@@ -187,7 +187,7 @@ export async function dbPipelineRestore(opt: DBPipelineRestoreOptions): Promise<
 
       await Pipeline.fromNDJsonFile<BaseDBEntity>(filePath)
         .limitSource(limit)
-        .tap(() => rows++)
+        .tapSync(() => rows++)
         .logProgress({
           logEvery: 1000,
           ...opt,

package/src/query/dbQuery.ts

@@ -1,13 +1,12 @@
 import { _truncate } from '@naturalcycles/js-lib/string/string.util.js'
-import type { AsyncIndexedMapper, BaseDBEntity, ObjectWithId } from '@naturalcycles/js-lib/types'
+import type { BaseDBEntity, ObjectWithId } from '@naturalcycles/js-lib/types'
 import { _objectAssign } from '@naturalcycles/js-lib/types'
-import { Pipeline, type ReadableTyped } from '@naturalcycles/nodejs-lib/stream'
+import type { Pipeline } from '@naturalcycles/nodejs-lib/stream'
 import type { CommonDao } from '../commondao/common.dao.js'
 import type {
   CommonDaoOptions,
   CommonDaoReadOptions,
   CommonDaoStreamDeleteOptions,
-  CommonDaoStreamForEachOptions,
   CommonDaoStreamOptions,
 } from '../commondao/common.dao.model.js'
 import type { RunQueryResult } from '../db.model.js'
@@ -276,55 +275,22 @@ export class RunnableDBQuery<
     return await this.dao.patchByQuery(this, patch, opt)
   }
 
-  async streamQueryForEach(
-    mapper: AsyncIndexedMapper<BM, void>,
-    opt?: CommonDaoStreamForEachOptions<BM>,
-  ): Promise<void> {
-    await this.dao.streamQueryForEach(this, mapper, opt)
-  }
-
-  async streamQueryAsDBMForEach(
-    mapper: AsyncIndexedMapper<DBM, void>,
-    opt?: CommonDaoStreamForEachOptions<DBM>,
-  ): Promise<void> {
-    await this.dao.streamQueryAsDBMForEach(this, mapper, opt)
-  }
-
-  streamQuery(opt?: CommonDaoStreamOptions<BM>): ReadableTyped<BM> {
+  streamQuery(opt?: CommonDaoStreamOptions<BM>): Pipeline<BM> {
     return this.dao.streamQuery(this, opt)
   }
 
-  streamQueryAsDBM(opt?: CommonDaoStreamOptions<DBM>): ReadableTyped<DBM> {
+  streamQueryAsDBM(opt?: CommonDaoStreamOptions<DBM>): Pipeline<DBM> {
     return this.dao.streamQueryAsDBM(this, opt)
   }
 
-  pipeline(opt?: CommonDaoStreamOptions<BM>): Pipeline<BM> {
-    return Pipeline.from(this.dao.streamQuery(this, opt))
-  }
-
-  pipelineAsDBM(opt?: CommonDaoStreamOptions<DBM>): Pipeline<DBM> {
-    return Pipeline.from(this.dao.streamQueryAsDBM(this, opt))
-  }
-
   async queryIds(opt?: CommonDaoReadOptions): Promise<ID[]> {
     return await this.dao.queryIds(this, opt)
   }
 
-  streamQueryIds(opt?: CommonDaoStreamOptions<ID>): ReadableTyped<ID> {
+  streamQueryIds(opt?: CommonDaoStreamOptions<ID>): Pipeline<ID> {
     return this.dao.streamQueryIds(this, opt)
   }
 
-  pipelineIds(opt?: CommonDaoStreamOptions<ID>): Pipeline<ID> {
-    return Pipeline.from(this.dao.streamQueryIds(this, opt))
-  }
-
-  async streamQueryIdsForEach(
-    mapper: AsyncIndexedMapper<ID, void>,
-    opt?: CommonDaoStreamForEachOptions<ID>,
-  ): Promise<void> {
-    await this.dao.streamQueryIdsForEach(this, mapper, opt)
-  }
-
   async deleteByQuery(opt?: CommonDaoStreamDeleteOptions<DBM>): Promise<number> {
     return await this.dao.deleteByQuery(this, opt)
   }

package/src/testing/commonDBTest.ts

@@ -354,8 +354,8 @@ export async function runCommonDBTest(
           // It should fail on id == null
           await tx.saveBatch(TEST_TABLE, [{ ...items[0]!, k1: 5, id: null as any }])
         })
-      } catch (err_) {
-        err = err_
+      } catch (err2) {
+        err = err2
       }
 
       expect(err).toBeDefined()

package/src/testing/commonDaoTest.ts

@@ -245,7 +245,10 @@ export async function runCommonDaoTest(
   if (support.streaming) {
     test('streamQueryForEach all', async () => {
       let rows: TestItemBM[] = []
-      await dao.query().streamQueryForEach(bm => void rows.push(bm))
+      await dao
+        .query()
+        .streamQuery()
+        .forEachSync(bm => void rows.push(bm))
 
       rows = _sortBy(rows, r => r.id)
       expectMatch(expectedItems, rows, quirks)
@@ -260,7 +263,10 @@ export async function runCommonDaoTest(
 
     test('streamQueryIdsForEach all', async () => {
       let ids: string[] = []
-      await dao.query().streamQueryIdsForEach(id => void ids.push(id))
+      await dao
+        .query()
+        .streamQueryIds()
+        .forEachSync(id => void ids.push(id))
       ids = ids.sort()
       expectMatch(
         expectedItems.map(i => i.id),
@@ -406,8 +412,8 @@ export async function runCommonDaoTest(
           await tx.deleteById(dao, items[2]!.id)
           await tx.save(dao, { ...items[0]!, k1: 5 as any }) // it should fail here
         })
-      } catch (err_) {
-        err = err_
+      } catch (err2) {
+        err = err2
       }
 
       expect(err).toBeDefined()
@@ -427,8 +433,8 @@ export async function runCommonDaoTest(
           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_
+        } catch (err2) {
+          err = err2
         }
 
         expect(err).toBeDefined()

package/src/testing/test.model.ts

@@ -58,7 +58,7 @@ export const testItemBMJsonSchema: JsonSchemaObject<TestItemBM> = j
     created: j.unixTimestamp(),
     updated: j.unixTimestamp(),
     k1: j.string(),
-    k2: j.oneOf<string | null>([j.string(), j.null()]).optional(),
+    k2: j.oneOf([j.string(), j.null()]).optional(),
     k3: j.number().optional(),
     even: j.boolean().optional(),
     b1: j.buffer().optional(),