@naturalcycles/db-lib 9.9.2 → 9.10.1

package/dist/commondao/common.dao.js

@@ -361,6 +361,17 @@ class CommonDao {
         const partialQuery = !!q._selectedFieldNames;
         if (partialQuery)
             return stream;
+        // This almost works, but hard to implement `errorMode: THROW_AGGREGATED` in this case
+        // return stream.flatMap(async (dbm: DBM) => {
+        //   if (this.cfg.hooks!.afterLoad) {
+        //     dbm = (await this.cfg.hooks!.afterLoad(dbm))!
+        //     if (dbm === null) return [] // SKIP
+        //   }
+        //
+        //   return [await this.dbmToBM(dbm, opt)] satisfies BM[]
+        // }, {
+        //   concurrency: 16,
+        // })
         return (stream
             // optimization: 1 validation is enough
             // .pipe(transformMap<any, DBM>(dbm => this.anyToDBM(dbm, opt), safeOpt))
@@ -376,10 +387,11 @@ class CommonDao {
         }, {
             errorMode: opt.errorMode,
         }))
-        // this can make the stream async-iteration-friendly
-        // but not applying it now for perf reasons
-        // .pipe(transformNoOp())
-        );
+            // this can make the stream async-iteration-friendly
+            // but not applying it now for perf reasons
+            // UPD: applying, to be compliant with `.toArray()`, etc.
+            .on('error', err => stream.emit('error', err))
+            .pipe((0, nodejs_lib_1.transformNoOp)()));
     }
     async queryIds(q, opt = {}) {
         q.table = opt.table || q.table;
@@ -389,12 +401,19 @@ class CommonDao {
     streamQueryIds(q, opt = {}) {
         q.table = opt.table || q.table;
         opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
+        // Experimental: using `.map()`
         const stream = this.cfg.db
             .streamQuery(q.select(['id']), opt)
-            .on('error', err => stream.emit('error', err))
-            .pipe((0, nodejs_lib_1.transformMapSimple)(r => r.id, {
-            errorMode: js_lib_1.ErrorMode.SUPPRESS, // cause .pipe() cannot propagate errors
-        }));
+            // .on('error', err => stream.emit('error', err))
+            .map((r) => r.id);
+        // const stream: ReadableTyped<string> = this.cfg.db
+        //   .streamQuery<DBM>(q.select(['id']), opt)
+        //   .on('error', err => stream.emit('error', err))
+        //   .pipe(
+        //     transformMapSimple<DBM, string>(r => r.id, {
+        //       errorMode: ErrorMode.SUPPRESS, // cause .pipe() cannot propagate errors
+        //     }),
+        //   )
         return stream;
     }
     async streamQueryIdsForEach(q, mapper, opt = {}) {

package/dist/kv/commonKeyValueDao.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { KeyValueTuple } from '@naturalcycles/js-lib';
+import { CommonLogger, KeyValueTuple } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDaoLogLevel } from '../commondao/common.dao.model';
 import { CommonDBCreateOptions } from '../db.model';
@@ -12,6 +12,10 @@ export interface CommonKeyValueDaoCfg<T> {
      * Set to true to limit DB writing (will throw an error is such case).
      */
     readOnly?: boolean;
+    /**
+     * Default to console
+     */
+    logger?: CommonLogger;
     /**
      * @default OPERATIONS
      */
@@ -33,8 +37,11 @@ export interface CommonKeyValueDaoCfg<T> {
     deflatedJsonValue?: boolean;
 }
 export declare class CommonKeyValueDao<T> {
-    cfg: CommonKeyValueDaoCfg<T>;
     constructor(cfg: CommonKeyValueDaoCfg<T>);
+    cfg: CommonKeyValueDaoCfg<T> & {
+        hooks: NonNullable<CommonKeyValueDaoCfg<T>['hooks']>;
+        logger: CommonLogger;
+    };
     ping(): Promise<void>;
     createTable(opt?: CommonDBCreateOptions): Promise<void>;
     create(input?: Partial<T>): T;

package/dist/kv/commonKeyValueDao.js

@@ -7,9 +7,13 @@ const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 // todo: readonly
 class CommonKeyValueDao {
     constructor(cfg) {
-        this.cfg = cfg;
+        this.cfg = {
+            hooks: {},
+            logger: console,
+            ...cfg,
+        };
         if (cfg.deflatedJsonValue) {
-            cfg.hooks = {
+            this.cfg.hooks = {
                 mapValueToBuffer: async (v) => await (0, nodejs_lib_1.deflateString)(JSON.stringify(v)),
                 mapBufferToValue: async (buf) => JSON.parse(await (0, nodejs_lib_1.inflateToString)(buf)),
                 ...cfg.hooks,
@@ -24,7 +28,7 @@ class CommonKeyValueDao {
     }
     create(input = {}) {
         return {
-            ...this.cfg.hooks?.beforeCreate?.(input),
+            ...this.cfg.hooks.beforeCreate?.(input),
         };
     }
     async getById(id) {
@@ -66,7 +70,7 @@ class CommonKeyValueDao {
         if (r)
             return r[1];
         return {
-            ...this.cfg.hooks?.beforeCreate?.({}),
+            ...this.cfg.hooks.beforeCreate?.({}),
             ...part,
         };
     }
@@ -80,7 +84,7 @@ class CommonKeyValueDao {
     }
     async getByIds(ids) {
         const entries = await this.cfg.db.getByIds(this.cfg.table, ids);
-        if (!this.cfg.hooks?.mapBufferToValue)
+        if (!this.cfg.hooks.mapBufferToValue)
             return entries;
         return await (0, js_lib_1.pMap)(entries, async ([id, buf]) => [
             id,
@@ -97,8 +101,8 @@ class CommonKeyValueDao {
         await this.cfg.db.saveBatch(this.cfg.table, [[id, value]]);
     }
     async saveBatch(entries) {
-        let bufferEntries = [];
-        if (!this.cfg.hooks?.mapValueToBuffer) {
+        let bufferEntries;
+        if (!this.cfg.hooks.mapValueToBuffer) {
             bufferEntries = entries;
         }
         else {
@@ -122,29 +126,41 @@ class CommonKeyValueDao {
         return this.cfg.db.streamIds(this.cfg.table, limit);
     }
     streamValues(limit) {
-        if (!this.cfg.hooks?.mapBufferToValue) {
+        const { mapBufferToValue } = this.cfg.hooks;
+        if (!mapBufferToValue) {
             return this.cfg.db.streamValues(this.cfg.table, limit);
         }
-        // todo: consider it when readableMap supports `errorMode: SUPPRESS`
-        // readableMap(this.cfg.db.streamValues(this.cfg.table, limit), async buf => await this.cfg.hooks!.mapBufferToValue(buf))
         const stream = this.cfg.db
             .streamValues(this.cfg.table, limit)
-            .on('error', err => stream.emit('error', err))
-            .pipe((0, nodejs_lib_1.transformMap)(async (buf) => await this.cfg.hooks.mapBufferToValue(buf), {
-            errorMode: js_lib_1.ErrorMode.SUPPRESS, // cause .pipe cannot propagate errors
-        }));
+            // .on('error', err => stream.emit('error', err))
+            .flatMap(async (buf) => {
+            try {
+                return [await mapBufferToValue(buf)];
+            }
+            catch (err) {
+                this.cfg.logger.error(err);
+                return []; // SKIP
+            }
+        });
         return stream;
     }
     streamEntries(limit) {
-        if (!this.cfg.hooks?.mapBufferToValue) {
+        const { mapBufferToValue } = this.cfg.hooks;
+        if (!mapBufferToValue) {
             return this.cfg.db.streamEntries(this.cfg.table, limit);
         }
         const stream = this.cfg.db
             .streamEntries(this.cfg.table, limit)
-            .on('error', err => stream.emit('error', err))
-            .pipe((0, nodejs_lib_1.transformMap)(async ([id, buf]) => [id, await this.cfg.hooks.mapBufferToValue(buf)], {
-            errorMode: js_lib_1.ErrorMode.SUPPRESS, // cause .pipe cannot propagate errors
-        }));
+            // .on('error', err => stream.emit('error', err))
+            .flatMap(async ([id, buf]) => {
+            try {
+                return [[id, await mapBufferToValue(buf)]];
+            }
+            catch (err) {
+                this.cfg.logger.error(err);
+                return []; // SKIP
+            }
+        });
         return stream;
     }
 }

package/dist/testing/daoTest.js

@@ -144,9 +144,7 @@ function runCommonDaoTest(db, quirks = {}) {
             (0, dbTest_1.expectMatch)(expectedItems, rows, quirks);
         });
         test('streamQuery all', async () => {
-            // let rows = await readableToArray(dao.query().streamQuery())
-            // todo: remove transformNoOp after `transformMap` learns to be async-iteration-friendly
-            let rows = await (0, nodejs_lib_1.readableToArray)(dao.query().streamQuery().pipe((0, nodejs_lib_1.transformNoOp)()));
+            let rows = await dao.query().streamQuery().toArray();
             rows = (0, js_lib_1._sortBy)(rows, r => r.id);
             (0, dbTest_1.expectMatch)(expectedItems, rows, quirks);
         });
@@ -157,7 +155,7 @@ function runCommonDaoTest(db, quirks = {}) {
             (0, dbTest_1.expectMatch)(expectedItems.map(i => i.id), ids, quirks);
         });
         test('streamQueryIds all', async () => {
-            let ids = await (0, nodejs_lib_1.readableToArray)(dao.query().streamQueryIds());
+            let ids = await dao.query().streamQueryIds().toArray();
             ids = ids.sort();
             (0, dbTest_1.expectMatch)(expectedItems.map(i => i.id), ids, quirks);
         });

package/dist/testing/dbTest.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectMatch = exports.runCommonDBTest = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
-const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const common_db_1 = require("../common.db");
 const db_model_1 = require("../db.model");
 const dbQuery_1 = require("../query/dbQuery");
@@ -152,7 +151,7 @@ function runCommonDBTest(db, quirks = {}) {
     // STREAM
     if (support.streaming) {
         test('streamQuery all', async () => {
-            let rows = await (0, nodejs_lib_1.readableToArray)(db.streamQuery(queryAll()));
+            let rows = await db.streamQuery(queryAll()).toArray();
             rows = (0, js_lib_1._sortBy)(rows, r => r.id); // cause order is not specified in DBQuery
             expectMatch(items, rows, quirks);
         });

package/dist/testing/keyValueDBTest.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommonKeyValueDBTest = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
-const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const test_model_1 = require("./test.model");
 const testIds = (0, js_lib_1._range)(1, 4).map(n => `id${n}`);
 const testEntries = testIds.map(id => [id, Buffer.from(`${id}value`)]);
@@ -33,35 +32,35 @@ function runCommonKeyValueDBTest(db) {
         expect(await db.count(test_model_1.TEST_TABLE)).toBe(3);
     });
     test('streamIds', async () => {
-        const ids = await (0, nodejs_lib_1.readableToArray)(db.streamIds(test_model_1.TEST_TABLE));
+        const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
         ids.sort();
         expect(ids).toEqual(testIds);
     });
     test('streamIds limited', async () => {
-        const idsLimited = await (0, nodejs_lib_1.readableToArray)(db.streamIds(test_model_1.TEST_TABLE, 2));
+        const idsLimited = await db.streamIds(test_model_1.TEST_TABLE, 2).toArray();
         // Order is non-deterministic, so, cannot compare values
         // idsLimited.sort()
         // expect(idsLimited).toEqual(testIds.slice(0, 2))
         expect(idsLimited.length).toBe(2);
     });
     test('streamValues', async () => {
-        const values = await (0, nodejs_lib_1.readableToArray)(db.streamValues(test_model_1.TEST_TABLE));
+        const values = await db.streamValues(test_model_1.TEST_TABLE).toArray();
         values.sort();
         expect(values).toEqual(testEntries.map(e => e[1]));
     });
     test('streamValues limited', async () => {
-        const valuesLimited = await (0, nodejs_lib_1.readableToArray)(db.streamValues(test_model_1.TEST_TABLE, 2));
+        const valuesLimited = await db.streamValues(test_model_1.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 (0, nodejs_lib_1.readableToArray)(db.streamEntries(test_model_1.TEST_TABLE));
+        const entries = await db.streamEntries(test_model_1.TEST_TABLE).toArray();
         entries.sort();
         expect(entries).toEqual(testEntries);
     });
     test('streamEntries limited', async () => {
-        const entriesLimited = await (0, nodejs_lib_1.readableToArray)(db.streamEntries(test_model_1.TEST_TABLE, 2));
+        const entriesLimited = await db.streamEntries(test_model_1.TEST_TABLE, 2).toArray();
         // entriesLimited.sort()
         // expect(entriesLimited).toEqual(testEntries.slice(0, 2))
         expect(entriesLimited.length).toBe(2);

package/dist/testing/keyValueDaoTest.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommonKeyValueDaoTest = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
-const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const testIds = (0, js_lib_1._range)(1, 4).map(n => `id${n}`);
 const testEntries = testIds.map(id => [id, Buffer.from(`${id}value`)]);
 function runCommonKeyValueDaoTest(dao) {
@@ -26,35 +25,35 @@ function runCommonKeyValueDaoTest(dao) {
         expect(entries).toEqual(testEntries);
     });
     test('streamIds', async () => {
-        const ids = await (0, nodejs_lib_1.readableToArray)(dao.streamIds());
+        const ids = await dao.streamIds().toArray();
         ids.sort();
         expect(ids).toEqual(testIds);
     });
     test('streamIds limited', async () => {
-        const idsLimited = await (0, nodejs_lib_1.readableToArray)(dao.streamIds(2));
+        const idsLimited = await dao.streamIds(2).toArray();
         // Order is non-deterministic, so, cannot compare values
         // idsLimited.sort()
         // expect(idsLimited).toEqual(testIds.slice(0, 2))
         expect(idsLimited.length).toBe(2);
     });
     test('streamValues', async () => {
-        const values = await (0, nodejs_lib_1.readableToArray)(dao.streamValues());
+        const values = await dao.streamValues().toArray();
         values.sort();
         expect(values).toEqual(testEntries.map(e => e[1]));
     });
     test('streamValues limited', async () => {
-        const valuesLimited = await (0, nodejs_lib_1.readableToArray)(dao.streamValues(2));
+        const valuesLimited = await dao.streamValues(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 (0, nodejs_lib_1.readableToArray)(dao.streamEntries());
+        const entries = await dao.streamEntries().toArray();
         entries.sort();
         expect(entries).toEqual(testEntries);
     });
     test('streamEntries limited', async () => {
-        const entriesLimited = await (0, nodejs_lib_1.readableToArray)(dao.streamEntries(2));
+        const entriesLimited = await dao.streamEntries(2).toArray();
         // entriesLimited.sort()
         // expect(entriesLimited).toEqual(testEntries.slice(0, 2))
         expect(entriesLimited.length).toBe(2);

package/package.json

@@ -40,7 +40,7 @@
   "engines": {
     "node": ">=18.12"
   },
-  "version": "9.9.2",
+  "version": "9.10.1",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/readme.md

@@ -150,7 +150,7 @@ Returns `ReadableTyped` (typed wrapper of Node.js
 
 Streams in Node.js support back-pressure by default (if piped properly by the consumer).
 
-```typescript
+```ts
 const q = DBQuery.create('table1') // "return all items" query
 
 await _pipeline([
@@ -165,6 +165,14 @@ await _pipeline([
 // ...
 ```
 
+Alternative:
+
+```ts
+await db.streamQuery(q).forEach(item => {
+  console.log(item)
+})
+```
+
 ###### saveBatch
 
 `saveBatch<DBM>(table: string, dbms: DBM[]): Promise<void>`

package/src/commondao/common.dao.ts

@@ -40,6 +40,7 @@ import {
   transformLogProgress,
   transformMap,
   transformMapSimple,
+  transformNoOp,
   writableVoid,
 } from '@naturalcycles/nodejs-lib'
 import { DBLibError } from '../cnst'
@@ -494,7 +495,19 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
 
     const stream = this.cfg.db.streamQuery<DBM>(q, opt)
     const partialQuery = !!q._selectedFieldNames
-    if (partialQuery) return stream
+    if (partialQuery) return stream as any
+
+    // This almost works, but hard to implement `errorMode: THROW_AGGREGATED` in this case
+    // return stream.flatMap(async (dbm: DBM) => {
+    //   if (this.cfg.hooks!.afterLoad) {
+    //     dbm = (await this.cfg.hooks!.afterLoad(dbm))!
+    //     if (dbm === null) return [] // SKIP
+    //   }
+    //
+    //   return [await this.dbmToBM(dbm, opt)] satisfies BM[]
+    // }, {
+    //   concurrency: 16,
+    // })
 
     return (
       stream
@@ -517,9 +530,11 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
             },
           ),
         )
-      // this can make the stream async-iteration-friendly
-      // but not applying it now for perf reasons
-      // .pipe(transformNoOp())
+        // this can make the stream async-iteration-friendly
+        // but not applying it now for perf reasons
+        // UPD: applying, to be compliant with `.toArray()`, etc.
+        .on('error', err => stream.emit('error', err))
+        .pipe(transformNoOp())
     )
   }
 
@@ -533,14 +548,20 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     q.table = opt.table || q.table
     opt.errorMode ||= ErrorMode.SUPPRESS
 
+    // Experimental: using `.map()`
     const stream: ReadableTyped<string> = this.cfg.db
       .streamQuery<DBM>(q.select(['id']), opt)
-      .on('error', err => stream.emit('error', err))
-      .pipe(
-        transformMapSimple<DBM, string>(r => r.id, {
-          errorMode: ErrorMode.SUPPRESS, // cause .pipe() cannot propagate errors
-        }),
-      )
+      // .on('error', err => stream.emit('error', err))
+      .map((r: ObjectWithId) => r.id)
+
+    // const stream: ReadableTyped<string> = this.cfg.db
+    //   .streamQuery<DBM>(q.select(['id']), opt)
+    //   .on('error', err => stream.emit('error', err))
+    //   .pipe(
+    //     transformMapSimple<DBM, string>(r => r.id, {
+    //       errorMode: ErrorMode.SUPPRESS, // cause .pipe() cannot propagate errors
+    //     }),
+    //   )
 
     return stream
   }

package/src/kv/commonKeyValueDao.ts

@@ -1,10 +1,5 @@
-import { AppError, ErrorMode, KeyValueTuple, pMap } from '@naturalcycles/js-lib'
-import {
-  deflateString,
-  inflateToString,
-  ReadableTyped,
-  transformMap,
-} from '@naturalcycles/nodejs-lib'
+import { AppError, CommonLogger, KeyValueTuple, pMap } from '@naturalcycles/js-lib'
+import { deflateString, inflateToString, ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDaoLogLevel } from '../commondao/common.dao.model'
 import { CommonDBCreateOptions } from '../db.model'
 import { CommonKeyValueDB, KeyValueDBTuple } from './commonKeyValueDB'
@@ -20,6 +15,11 @@ export interface CommonKeyValueDaoCfg<T> {
    */
   readOnly?: boolean
 
+  /**
+   * Default to console
+   */
+  logger?: CommonLogger
+
   /**
    * @default OPERATIONS
    */
@@ -48,9 +48,15 @@ export interface CommonKeyValueDaoCfg<T> {
 // todo: readonly
 
 export class CommonKeyValueDao<T> {
-  constructor(public cfg: CommonKeyValueDaoCfg<T>) {
+  constructor(cfg: CommonKeyValueDaoCfg<T>) {
+    this.cfg = {
+      hooks: {},
+      logger: console,
+      ...cfg,
+    }
+
     if (cfg.deflatedJsonValue) {
-      cfg.hooks = {
+      this.cfg.hooks = {
         mapValueToBuffer: async v => await deflateString(JSON.stringify(v)),
         mapBufferToValue: async buf => JSON.parse(await inflateToString(buf)),
         ...cfg.hooks,
@@ -58,6 +64,11 @@ export class CommonKeyValueDao<T> {
     }
   }
 
+  cfg: CommonKeyValueDaoCfg<T> & {
+    hooks: NonNullable<CommonKeyValueDaoCfg<T>['hooks']>
+    logger: CommonLogger
+  }
+
   async ping(): Promise<void> {
     await this.cfg.db.ping()
   }
@@ -68,7 +79,7 @@ export class CommonKeyValueDao<T> {
 
   create(input: Partial<T> = {}): T {
     return {
-      ...this.cfg.hooks?.beforeCreate?.(input),
+      ...this.cfg.hooks.beforeCreate?.(input),
     } as T
   }
 
@@ -117,7 +128,7 @@ export class CommonKeyValueDao<T> {
     if (r) return r[1]
 
     return {
-      ...this.cfg.hooks?.beforeCreate?.({}),
+      ...this.cfg.hooks.beforeCreate?.({}),
       ...part,
     } as T
   }
@@ -135,11 +146,11 @@ export class CommonKeyValueDao<T> {
 
   async getByIds(ids: string[]): Promise<KeyValueTuple<string, T>[]> {
     const entries = await this.cfg.db.getByIds(this.cfg.table, ids)
-    if (!this.cfg.hooks?.mapBufferToValue) return entries as any
+    if (!this.cfg.hooks.mapBufferToValue) return entries as any
 
     return await pMap(entries, async ([id, buf]) => [
       id,
-      await this.cfg.hooks!.mapBufferToValue!(buf),
+      await this.cfg.hooks.mapBufferToValue!(buf),
     ])
   }
 
@@ -156,14 +167,14 @@ export class CommonKeyValueDao<T> {
   }
 
   async saveBatch(entries: KeyValueTuple<string, T>[]): Promise<void> {
-    let bufferEntries: KeyValueDBTuple[] = []
+    let bufferEntries: KeyValueDBTuple[]
 
-    if (!this.cfg.hooks?.mapValueToBuffer) {
+    if (!this.cfg.hooks.mapValueToBuffer) {
       bufferEntries = entries as any
     } else {
       bufferEntries = await pMap(entries, async ([id, v]) => [
         id,
-        await this.cfg.hooks!.mapValueToBuffer!(v),
+        await this.cfg.hooks.mapValueToBuffer!(v),
       ])
     }
 
@@ -187,37 +198,47 @@ export class CommonKeyValueDao<T> {
   }
 
   streamValues(limit?: number): ReadableTyped<T> {
-    if (!this.cfg.hooks?.mapBufferToValue) {
-      return this.cfg.db.streamValues(this.cfg.table, limit)
+    const { mapBufferToValue } = this.cfg.hooks
+
+    if (!mapBufferToValue) {
+      return this.cfg.db.streamValues(this.cfg.table, limit) as ReadableTyped<T>
     }
 
-    // todo: consider it when readableMap supports `errorMode: SUPPRESS`
-    // readableMap(this.cfg.db.streamValues(this.cfg.table, limit), async buf => await this.cfg.hooks!.mapBufferToValue(buf))
     const stream: ReadableTyped<T> = this.cfg.db
       .streamValues(this.cfg.table, limit)
-      .on('error', err => stream.emit('error', err))
-      .pipe(
-        transformMap(async buf => await this.cfg.hooks!.mapBufferToValue!(buf), {
-          errorMode: ErrorMode.SUPPRESS, // cause .pipe cannot propagate errors
-        }),
-      )
+      // .on('error', err => stream.emit('error', err))
+      .flatMap(async buf => {
+        try {
+          return [await mapBufferToValue(buf)]
+        } catch (err) {
+          this.cfg.logger.error(err)
+          return [] // SKIP
+        }
+      })
 
     return stream
   }
 
   streamEntries(limit?: number): ReadableTyped<KeyValueTuple<string, T>> {
-    if (!this.cfg.hooks?.mapBufferToValue) {
-      return this.cfg.db.streamEntries(this.cfg.table, limit)
+    const { mapBufferToValue } = this.cfg.hooks
+
+    if (!mapBufferToValue) {
+      return this.cfg.db.streamEntries(this.cfg.table, limit) as ReadableTyped<
+        KeyValueTuple<string, T>
+      >
     }
 
     const stream: ReadableTyped<KeyValueTuple<string, T>> = this.cfg.db
       .streamEntries(this.cfg.table, limit)
-      .on('error', err => stream.emit('error', err))
-      .pipe(
-        transformMap(async ([id, buf]) => [id, await this.cfg.hooks!.mapBufferToValue!(buf)], {
-          errorMode: ErrorMode.SUPPRESS, // cause .pipe cannot propagate errors
-        }),
-      )
+      // .on('error', err => stream.emit('error', err))
+      .flatMap(async ([id, buf]) => {
+        try {
+          return [[id, await mapBufferToValue(buf)]]
+        } catch (err) {
+          this.cfg.logger.error(err)
+          return [] // SKIP
+        }
+      })
 
     return stream
   }

package/src/testing/daoTest.ts

@@ -1,6 +1,6 @@
 import { Readable } from 'node:stream'
 import { _deepCopy, _pick, _sortBy, _omit, localTimeNow } from '@naturalcycles/js-lib'
-import { _pipeline, readableToArray, transformNoOp } from '@naturalcycles/nodejs-lib'
+import { _pipeline } from '@naturalcycles/nodejs-lib'
 import { CommonDaoLogLevel, DBQuery } from '..'
 import { CommonDB } from '../common.db'
 import { CommonDao } from '../commondao/common.dao'
@@ -194,11 +194,7 @@ export function runCommonDaoTest(db: CommonDB, quirks: CommonDBImplementationQui
     })
 
     test('streamQuery all', async () => {
-      // let rows = await readableToArray(dao.query().streamQuery())
-      // todo: remove transformNoOp after `transformMap` learns to be async-iteration-friendly
-      let rows: TestItemBM[] = await readableToArray(
-        dao.query().streamQuery().pipe(transformNoOp()),
-      )
+      let rows: TestItemBM[] = await dao.query().streamQuery().toArray()
 
       rows = _sortBy(rows, r => r.id)
       expectMatch(expectedItems, rows, quirks)
@@ -216,7 +212,7 @@ export function runCommonDaoTest(db: CommonDB, quirks: CommonDBImplementationQui
     })
 
     test('streamQueryIds all', async () => {
-      let ids = await readableToArray(dao.query().streamQueryIds())
+      let ids = await dao.query().streamQueryIds().toArray()
       ids = ids.sort()
       expectMatch(
         expectedItems.map(i => i.id),

package/src/testing/dbTest.ts

@@ -1,5 +1,4 @@
 import { _filterObject, _pick, _sortBy, pMap } from '@naturalcycles/js-lib'
-import { readableToArray } from '@naturalcycles/nodejs-lib'
 import { CommonDB, CommonDBType } from '../common.db'
 import { DBIncrement, DBPatch } from '../db.model'
 import { DBQuery } from '../query/dbQuery'
@@ -220,7 +219,7 @@ export function runCommonDBTest(db: CommonDB, quirks: CommonDBImplementationQuir
   // STREAM
   if (support.streaming) {
     test('streamQuery all', async () => {
-      let rows = await readableToArray(db.streamQuery(queryAll()))
+      let rows = await db.streamQuery(queryAll()).toArray()
 
       rows = _sortBy(rows, r => r.id) // cause order is not specified in DBQuery
       expectMatch(items, rows, quirks)

package/src/testing/keyValueDBTest.ts

@@ -1,5 +1,4 @@
 import { _range, _sortBy } from '@naturalcycles/js-lib'
-import { readableToArray } from '@naturalcycles/nodejs-lib'
 import { CommonKeyValueDB, KeyValueDBTuple } from '../kv/commonKeyValueDB'
 import { TEST_TABLE } from './test.model'
 
@@ -42,13 +41,13 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
   })
 
   test('streamIds', async () => {
-    const ids = await readableToArray(db.streamIds(TEST_TABLE))
+    const ids = await db.streamIds(TEST_TABLE).toArray()
     ids.sort()
     expect(ids).toEqual(testIds)
   })
 
   test('streamIds limited', async () => {
-    const idsLimited = await readableToArray(db.streamIds(TEST_TABLE, 2))
+    const idsLimited = await db.streamIds(TEST_TABLE, 2).toArray()
     // Order is non-deterministic, so, cannot compare values
     // idsLimited.sort()
     // expect(idsLimited).toEqual(testIds.slice(0, 2))
@@ -56,26 +55,26 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
   })
 
   test('streamValues', async () => {
-    const values = await readableToArray(db.streamValues(TEST_TABLE))
+    const values = await db.streamValues(TEST_TABLE).toArray()
     values.sort()
     expect(values).toEqual(testEntries.map(e => e[1]))
   })
 
   test('streamValues limited', async () => {
-    const valuesLimited = await readableToArray(db.streamValues(TEST_TABLE, 2))
+    const valuesLimited = await db.streamValues(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 readableToArray(db.streamEntries(TEST_TABLE))
+    const entries = await db.streamEntries(TEST_TABLE).toArray()
     entries.sort()
     expect(entries).toEqual(testEntries)
   })
 
   test('streamEntries limited', async () => {
-    const entriesLimited = await readableToArray(db.streamEntries(TEST_TABLE, 2))
+    const entriesLimited = await db.streamEntries(TEST_TABLE, 2).toArray()
     // entriesLimited.sort()
     // expect(entriesLimited).toEqual(testEntries.slice(0, 2))
     expect(entriesLimited.length).toBe(2)

package/src/testing/keyValueDaoTest.ts

@@ -1,5 +1,4 @@
 import { _range, _sortBy } from '@naturalcycles/js-lib'
-import { readableToArray } from '@naturalcycles/nodejs-lib'
 import { KeyValueDBTuple } from '../kv/commonKeyValueDB'
 import { CommonKeyValueDao } from '../kv/commonKeyValueDao'
 
@@ -33,13 +32,13 @@ export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
   })
 
   test('streamIds', async () => {
-    const ids = await readableToArray(dao.streamIds())
+    const ids = await dao.streamIds().toArray()
     ids.sort()
     expect(ids).toEqual(testIds)
   })
 
   test('streamIds limited', async () => {
-    const idsLimited = await readableToArray(dao.streamIds(2))
+    const idsLimited = await dao.streamIds(2).toArray()
     // Order is non-deterministic, so, cannot compare values
     // idsLimited.sort()
     // expect(idsLimited).toEqual(testIds.slice(0, 2))
@@ -47,26 +46,26 @@ export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
   })
 
   test('streamValues', async () => {
-    const values = await readableToArray(dao.streamValues())
+    const values = await dao.streamValues().toArray()
     values.sort()
     expect(values).toEqual(testEntries.map(e => e[1]))
   })
 
   test('streamValues limited', async () => {
-    const valuesLimited = await readableToArray(dao.streamValues(2))
+    const valuesLimited = await dao.streamValues(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 readableToArray(dao.streamEntries())
+    const entries = await dao.streamEntries().toArray()
     entries.sort()
     expect(entries).toEqual(testEntries)
   })
 
   test('streamEntries limited', async () => {
-    const entriesLimited = await readableToArray(dao.streamEntries(2))
+    const entriesLimited = await dao.streamEntries(2).toArray()
     // entriesLimited.sort()
     // expect(entriesLimited).toEqual(testEntries.slice(0, 2))
     expect(entriesLimited.length).toBe(2)