@naturalcycles/db-lib 10.37.0 → 10.38.0

package/dist/commondao/common.dao.d.ts

@@ -1,7 +1,6 @@
-import type { Transform } from 'node:stream';
 import { type BaseDBEntity, type NonNegativeInteger, type StringMap, type Unsaved } from '@naturalcycles/js-lib/types';
 import type { JsonSchema } from '@naturalcycles/nodejs-lib/ajv';
-import { type Pipeline } from '@naturalcycles/nodejs-lib/stream';
+import type { Pipeline } from '@naturalcycles/nodejs-lib/stream';
 import type { CommonDBTransactionOptions, RunQueryResult } from '../db.model.js';
 import type { DBQuery } from '../query/dbQuery.js';
 import { RunnableDBQuery } from '../query/dbQuery.js';
@@ -92,8 +91,11 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * (of size opt.chunkSize, which defaults to 500),
      * and then executing db.saveBatch(chunk) with the concurrency
      * of opt.chunkConcurrency (which defaults to 32).
+     *
+     * It takes a Pipeline as input, appends necessary saving transforms to it,
+     * and calls .run() on it.
      */
-    streamSaveTransforms(opt?: CommonDaoStreamSaveOptions<DBM>): Transform[];
+    streamSave(p: Pipeline<BM>, opt?: CommonDaoStreamSaveOptions<DBM>): Promise<void>;
     /**
      * @returns number of deleted items
      */

package/dist/commondao/common.dao.js

@@ -7,7 +7,6 @@ import { _filterUndefinedValues, _objectAssignExact, } from '@naturalcycles/js-l
 import { pMap } from '@naturalcycles/js-lib/promise/pMap.js';
 import { _passthroughPredicate, _stringMapEntries, _stringMapValues, _typeCast, } from '@naturalcycles/js-lib/types';
 import { stringId } from '@naturalcycles/nodejs-lib';
-import { transformChunk, transformFlatten, transformLogProgress, transformMap, } from '@naturalcycles/nodejs-lib/stream';
 import { DBLibError } from '../cnst.js';
 import { RunnableDBQuery } from '../query/dbQuery.js';
 import { CommonDaoTransaction } from './commonDaoTransaction.js';
@@ -401,8 +400,11 @@ export class CommonDao {
      * (of size opt.chunkSize, which defaults to 500),
      * and then executing db.saveBatch(chunk) with the concurrency
      * of opt.chunkConcurrency (which defaults to 32).
+     *
+     * It takes a Pipeline as input, appends necessary saving transforms to it,
+     * and calls .run() on it.
      */
-    streamSaveTransforms(opt = {}) {
+    async streamSave(p, opt = {}) {
         this.requireWriteAccess();
         const table = opt.table || this.cfg.table;
         opt.skipValidation ??= true;
@@ -413,32 +415,29 @@ export class CommonDao {
         const excludeFromIndexes = opt.excludeFromIndexes || this.cfg.excludeFromIndexes;
         const { beforeSave } = this.cfg.hooks;
         const { chunkSize = 500, chunkConcurrency = 32, errorMode } = opt;
-        return [
-            transformMap(async (bm) => {
-                this.assignIdCreatedUpdated(bm, opt);
-                const dbm = await this.bmToDBM(bm, opt);
-                beforeSave?.(dbm);
-                return dbm;
-            }, {
-                errorMode,
-            }),
-            transformChunk(chunkSize),
-            transformMap(async (batch) => {
-                await this.cfg.db.saveBatch(table, batch, {
-                    ...opt,
-                    excludeFromIndexes,
-                });
-                return batch;
-            }, {
-                concurrency: chunkConcurrency,
-                errorMode,
-            }),
-            transformFlatten(),
-            transformLogProgress({
-                metric: 'saved',
+        await p
+            .map(async (bm) => {
+            this.assignIdCreatedUpdated(bm, opt);
+            const dbm = await this.bmToDBM(bm, opt);
+            beforeSave?.(dbm);
+            return dbm;
+        }, { errorMode })
+            .chunk(chunkSize)
+            .map(async (batch) => {
+            await this.cfg.db.saveBatch(table, batch, {
                 ...opt,
-            }),
-        ];
+                excludeFromIndexes,
+            });
+            return batch;
+        }, {
+            concurrency: chunkConcurrency,
+            errorMode,
+        })
+            .logProgress({
+            metric: 'saved',
+            ...opt,
+        })
+            .run();
     }
     // DELETE
     /**

package/dist/testing/commonDaoTest.js

@@ -205,10 +205,10 @@ export async function runCommonDaoTest(db, quirks = {}) {
             ids = ids.sort();
             expectMatch(expectedItems.map(i => i.id), ids, quirks);
         });
-        test('streamSaveTransform', async () => {
+        test('streamSave', async () => {
             const items2 = createTestItemsBM(2).map(i => ({ ...i, id: i.id + '_str' }));
             const ids = items2.map(i => i.id);
-            await Pipeline.fromArray(items2).transformMany(dao.streamSaveTransforms()).run();
+            await dao.streamSave(Pipeline.fromArray(items2));
             const items2Loaded = await dao.getByIds(ids);
             expectMatch(items2, items2Loaded, quirks);
             // cleanup

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@naturalcycles/db-lib",
   "type": "module",
-  "version": "10.37.0",
+  "version": "10.38.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@naturalcycles/nodejs-lib": "^15"
   },
   "devDependencies": {
-    "@naturalcycles/dev-lib": "20.15.0"
+    "@naturalcycles/dev-lib": "18.4.2"
   },
   "files": [
     "dist",

package/src/commondao/common.dao.ts

@@ -1,4 +1,3 @@
-import type { Transform } from 'node:stream'
 import { _isTruthy } from '@naturalcycles/js-lib'
 import { _uniqBy } from '@naturalcycles/js-lib/array/array.util.js'
 import { localTime } from '@naturalcycles/js-lib/datetime/localTime.js'
@@ -22,13 +21,7 @@ import {
 } from '@naturalcycles/js-lib/types'
 import { stringId } from '@naturalcycles/nodejs-lib'
 import type { JsonSchema } from '@naturalcycles/nodejs-lib/ajv'
-import {
-  type Pipeline,
-  transformChunk,
-  transformFlatten,
-  transformLogProgress,
-  transformMap,
-} from '@naturalcycles/nodejs-lib/stream'
+import type { Pipeline } from '@naturalcycles/nodejs-lib/stream'
 import { DBLibError } from '../cnst.js'
 import type {
   CommonDBSaveOptions,
@@ -542,8 +535,11 @@ export class CommonDao<
    * (of size opt.chunkSize, which defaults to 500),
    * and then executing db.saveBatch(chunk) with the concurrency
    * of opt.chunkConcurrency (which defaults to 32).
+   *
+   * It takes a Pipeline as input, appends necessary saving transforms to it,
+   * and calls .run() on it.
    */
-  streamSaveTransforms(opt: CommonDaoStreamSaveOptions<DBM> = {}): Transform[] {
+  async streamSave(p: Pipeline<BM>, opt: CommonDaoStreamSaveOptions<DBM> = {}): Promise<void> {
     this.requireWriteAccess()
 
     const table = opt.table || this.cfg.table
@@ -559,20 +555,18 @@ export class CommonDao<
 
     const { chunkSize = 500, chunkConcurrency = 32, errorMode } = opt
 
-    return [
-      transformMap<BM, DBM>(
+    await p
+      .map(
         async bm => {
           this.assignIdCreatedUpdated(bm, opt)
           const dbm = await this.bmToDBM(bm, opt)
           beforeSave?.(dbm)
           return dbm
         },
-        {
-          errorMode,
-        },
-      ),
-      transformChunk<DBM>(chunkSize),
-      transformMap<DBM[], DBM[]>(
+        { errorMode },
+      )
+      .chunk(chunkSize)
+      .map(
         async batch => {
           await this.cfg.db.saveBatch(table, batch, {
             ...opt,
@@ -584,13 +578,12 @@ export class CommonDao<
           concurrency: chunkConcurrency,
           errorMode,
         },
-      ),
-      transformFlatten(),
-      transformLogProgress({
+      )
+      .logProgress({
         metric: 'saved',
         ...opt,
-      }),
-    ]
+      })
+      .run()
   }
 
   // DELETE

package/src/testing/commonDaoTest.ts

@@ -285,11 +285,11 @@ export async function runCommonDaoTest(
       )
     })
 
-    test('streamSaveTransform', async () => {
+    test('streamSave', async () => {
       const items2 = createTestItemsBM(2).map(i => ({ ...i, id: i.id + '_str' }))
       const ids = items2.map(i => i.id)
 
-      await Pipeline.fromArray(items2).transformMany(dao.streamSaveTransforms()).run()
+      await dao.streamSave(Pipeline.fromArray(items2))
 
       const items2Loaded = await dao.getByIds(ids)
       expectMatch(items2, items2Loaded, quirks)