@naturalcycles/db-lib 10.47.1 → 10.49.0

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

@@ -143,11 +143,11 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * const storageRow = await dao.dbmToStorageRow(dbm)
      * await db.saveBatch(table, [storageRow])
      */
-    dbmToStorageRow(dbm: DBM): Promise<ObjectWithId>;
+    dbmToStorageRow(dbm: DBM): ObjectWithId;
     /**
      * Converts multiple DBMs to storage rows.
      */
-    dbmsToStorageRows(dbms: DBM[]): Promise<ObjectWithId[]>;
+    dbmsToStorageRows(dbms: DBM[]): ObjectWithId[];
     /**
      * Converts a storage row back to a DBM, applying decompression if needed.
      *
@@ -157,12 +157,18 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * const rows = await db.getByIds(table, ids)
      * const dbms = await Promise.all(rows.map(row => dao.storageRowToDBM(row)))
      */
-    storageRowToDBM(row: ObjectWithId): Promise<DBM>;
+    storageRowToDBM(row: ObjectWithId): DBM;
     /**
      * Converts multiple storage rows to DBMs.
      */
-    storageRowsToDBMs(rows: ObjectWithId[]): Promise<DBM[]>;
+    storageRowsToDBM(rows: ObjectWithId[]): DBM[];
+    /**
+     * Mutates `dbm`.
+     */
     private compress;
+    /**
+     * Mutates `dbm`.
+     */
     private decompress;
     anyToDBM(dbm: undefined, opt?: CommonDaoOptions): null;
     anyToDBM(dbm?: any, opt?: CommonDaoOptions): DBM;

package/dist/commondao/common.dao.js

@@ -7,7 +7,7 @@ import { _filterUndefinedValues, _objectAssignExact, _omitWithUndefined, _pick,
 import { pMap } from '@naturalcycles/js-lib/promise/pMap.js';
 import { _objectKeys, _passthroughPredicate, _stringMapEntries, _stringMapValues, _typeCast, } from '@naturalcycles/js-lib/types';
 import { stringId } from '@naturalcycles/nodejs-lib';
-import { decompressZstdOrInflateToString, zstdCompress } from '@naturalcycles/nodejs-lib/zip';
+import { zip2 } from '@naturalcycles/nodejs-lib/zip';
 import { DBLibError } from '../cnst.js';
 import { RunnableDBQuery } from '../query/dbQuery.js';
 import { CommonDaoTransaction } from './commonDaoTransaction.js';
@@ -105,7 +105,7 @@ export class CommonDao {
             return [];
         const table = opt.table || this.cfg.table;
         const rows = await (opt.tx || this.cfg.db).getByIds(table, ids, opt);
-        return await this.storageRowsToDBMs(rows);
+        return this.storageRowsToDBM(rows);
     }
     async getBy(by, value, limit = 0, opt) {
         return await this.query().filterEq(by, value).limit(limit).runQuery(opt);
@@ -148,7 +148,7 @@ export class CommonDao {
         q.table = opt.table || q.table;
         const { rows: rawRows, ...queryResult } = await this.cfg.db.runQuery(q, opt);
         const isPartialQuery = !!q._selectedFieldNames;
-        const rows = isPartialQuery ? rawRows : await this.storageRowsToDBMs(rawRows);
+        const rows = isPartialQuery ? rawRows : this.storageRowsToDBM(rawRows);
         const bms = isPartialQuery ? rows : this.dbmsToBM(rows, opt);
         return {
             rows: bms,
@@ -164,7 +164,7 @@ export class CommonDao {
         q.table = opt.table || q.table;
         const { rows: rawRows, ...queryResult } = await this.cfg.db.runQuery(q, opt);
         const isPartialQuery = !!q._selectedFieldNames;
-        const rows = isPartialQuery ? rawRows : await this.storageRowsToDBMs(rawRows);
+        const rows = isPartialQuery ? rawRows : this.storageRowsToDBM(rawRows);
         const dbms = isPartialQuery ? rows : this.anyToDBMs(rows, opt);
         return { rows: dbms, ...queryResult };
     }
@@ -178,10 +178,7 @@ export class CommonDao {
         q.table = opt.table || q.table;
         let pipeline = this.cfg.db.streamQuery(q, opt);
         if (this.cfg.compress?.keys.length) {
-            pipeline = pipeline.map(async row => await this.storageRowToDBM(row), {
-                // lowered, to reduce the total buffer size a bit for uncompressed objects
-                highWaterMark: 16,
-            });
+            pipeline = pipeline.mapSync(row => this.storageRowToDBM(row));
         }
         const isPartialQuery = !!q._selectedFieldNames;
         if (isPartialQuery)
@@ -195,10 +192,7 @@ export class CommonDao {
         q.table = opt.table || q.table;
         let pipeline = this.cfg.db.streamQuery(q, opt);
         if (this.cfg.compress?.keys.length) {
-            pipeline = pipeline.map(async row => await this.storageRowToDBM(row), {
-                // lowered, to reduce the total buffer size a bit for uncompressed objects
-                highWaterMark: 16,
-            });
+            pipeline = pipeline.mapSync(row => this.storageRowToDBM(row));
         }
         const isPartialQuery = !!q._selectedFieldNames;
         if (isPartialQuery)
@@ -357,7 +351,7 @@ export class CommonDao {
         this.cfg.hooks.beforeSave?.(dbm);
         const table = opt.table || this.cfg.table;
         const saveOptions = this.prepareSaveOptions(opt);
-        const row = await this.dbmToStorageRow(dbm);
+        const row = this.dbmToStorageRow(dbm);
         await (opt.tx || this.cfg.db).saveBatch(table, [row], saveOptions);
         if (saveOptions.assignGeneratedIds) {
             bm.id = dbm.id;
@@ -371,7 +365,7 @@ export class CommonDao {
         this.cfg.hooks.beforeSave?.(validDbm);
         const table = opt.table || this.cfg.table;
         const saveOptions = this.prepareSaveOptions(opt);
-        const row = await this.dbmToStorageRow(validDbm);
+        const row = this.dbmToStorageRow(validDbm);
         await (opt.tx || this.cfg.db).saveBatch(table, [row], saveOptions);
         if (saveOptions.assignGeneratedIds) {
             dbm.id = validDbm.id;
@@ -389,7 +383,7 @@ export class CommonDao {
         }
         const table = opt.table || this.cfg.table;
         const saveOptions = this.prepareSaveOptions(opt);
-        const rows = await this.dbmsToStorageRows(dbms);
+        const rows = this.dbmsToStorageRows(dbms);
         await (opt.tx || this.cfg.db).saveBatch(table, rows, saveOptions);
         if (saveOptions.assignGeneratedIds) {
             dbms.forEach((dbm, i) => (bms[i].id = dbm.id));
@@ -407,7 +401,7 @@ export class CommonDao {
         }
         const table = opt.table || this.cfg.table;
         const saveOptions = this.prepareSaveOptions(opt);
-        const rows = await this.dbmsToStorageRows(validDbms);
+        const rows = this.dbmsToStorageRows(validDbms);
         await (opt.tx || this.cfg.db).saveBatch(table, rows, saveOptions);
         if (saveOptions.assignGeneratedIds) {
             validDbms.forEach((dbm, i) => (dbms[i].id = dbm.id));
@@ -457,7 +451,7 @@ export class CommonDao {
             this.assignIdCreatedUpdated(bm, opt);
             const dbm = this.bmToDBM(bm, opt);
             beforeSave?.(dbm);
-            return await this.dbmToStorageRow(dbm);
+            return this.dbmToStorageRow(dbm);
         }, { errorMode })
             .chunk(chunkSize)
             .map(async batch => {
@@ -606,20 +600,24 @@ export class CommonDao {
      * const storageRow = await dao.dbmToStorageRow(dbm)
      * await db.saveBatch(table, [storageRow])
      */
-    async dbmToStorageRow(dbm) {
+    dbmToStorageRow(dbm) {
         if (!this.cfg.compress?.keys.length)
             return dbm;
         const row = { ...dbm };
-        await this.compress(row);
+        this.compress(row);
         return row;
     }
     /**
      * Converts multiple DBMs to storage rows.
      */
-    async dbmsToStorageRows(dbms) {
+    dbmsToStorageRows(dbms) {
         if (!this.cfg.compress?.keys.length)
             return dbms;
-        return await pMap(dbms, async dbm => await this.dbmToStorageRow(dbm));
+        return dbms.map(dbm => {
+            const row = { ...dbm };
+            this.compress(row);
+            return row;
+        });
     }
     /**
      * Converts a storage row back to a DBM, applying decompression if needed.
@@ -630,43 +628,46 @@ export class CommonDao {
      * const rows = await db.getByIds(table, ids)
      * const dbms = await Promise.all(rows.map(row => dao.storageRowToDBM(row)))
      */
-    async storageRowToDBM(row) {
+    storageRowToDBM(row) {
         if (!this.cfg.compress?.keys.length)
             return row;
         const dbm = { ...row };
-        await this.decompress(dbm);
+        this.decompress(dbm);
         return dbm;
     }
     /**
      * Converts multiple storage rows to DBMs.
      */
-    async storageRowsToDBMs(rows) {
+    storageRowsToDBM(rows) {
         if (!this.cfg.compress?.keys.length)
             return rows;
-        return await pMap(rows, async row => await this.storageRowToDBM(row));
+        return rows.map(row => {
+            const dbm = { ...row };
+            this.decompress(dbm);
+            return dbm;
+        });
     }
     /**
      * Mutates `dbm`.
      */
-    async compress(dbm) {
+    compress(dbm) {
         if (!this.cfg.compress?.keys.length)
             return; // No compression requested
         const { keys, level = 1 } = this.cfg.compress;
         const properties = _pick(dbm, keys);
         const bufferString = JSON.stringify(properties);
-        const __compressed = await zstdCompress(bufferString, level);
+        const __compressed = zip2.zstdCompressSync(bufferString, level);
         _omitWithUndefined(dbm, _objectKeys(properties), { mutate: true });
         Object.assign(dbm, { __compressed });
     }
     /**
      * Mutates `dbm`.
      */
-    async decompress(dbm) {
+    decompress(dbm) {
         _typeCast(dbm);
         if (!Buffer.isBuffer(dbm.__compressed))
             return; // No compressed data
-        // todo: stop supporting Inflate when we are sure that we have migrated everything to zstd
-        const bufferString = await decompressZstdOrInflateToString(dbm.__compressed);
+        const bufferString = zip2.zstdDecompressToStringSync(dbm.__compressed);
         const properties = JSON.parse(bufferString);
         dbm.__compressed = undefined;
         Object.assign(dbm, properties);
@@ -769,7 +770,7 @@ export class CommonDao {
         // todo: support tx
         const dbmsByTable = await db.multiGet(idsByTable, opt);
         const dbmByTableById = CommonDao.multiGetMapByTableById(dbmsByTable);
-        return (await CommonDao.prepareMultiGetOutput(inputMap, dbmByTableById, opt));
+        return CommonDao.prepareMultiGetOutput(inputMap, dbmByTableById, opt);
     }
     static prepareMultiGetIds(inputMap) {
         const idSetByTable = {};
@@ -806,17 +807,17 @@ export class CommonDao {
         }
         return dbmByTableById;
     }
-    static async prepareMultiGetOutput(inputMap, dbmByTableById, opt = {}) {
+    static prepareMultiGetOutput(inputMap, dbmByTableById, opt = {}) {
         const bmsByProp = {};
         // Loop over input props again, to produce the output of the same shape as requested
-        await pMap(_stringMapEntries(inputMap), async ([prop, input]) => {
+        for (const [prop, input] of _stringMapEntries(inputMap)) {
             const { dao } = input;
             const { table } = dao.cfg;
             if ('id' in input) {
                 // Singular
                 const row = dbmByTableById[table][input.id];
                 // Decompress before converting to BM
-                const dbm = row ? await dao.storageRowToDBM(row) : undefined;
+                const dbm = row ? dao.storageRowToDBM(row) : undefined;
                 bmsByProp[prop] = dao.dbmToBM(dbm, opt) || null;
             }
             else {
@@ -825,10 +826,10 @@ export class CommonDao {
                 // Without filtering - every prop will get ALL rows from that table.
                 const rows = input.ids.map(id => dbmByTableById[table][id]).filter(_isTruthy);
                 // Decompress before converting to BM
-                const dbms = await dao.storageRowsToDBMs(rows);
+                const dbms = dao.storageRowsToDBM(rows);
                 bmsByProp[prop] = dao.dbmsToBM(dbms, opt);
             }
-        });
+        }
         return bmsByProp;
     }
     /**
@@ -859,7 +860,7 @@ export class CommonDao {
             return;
         const { db } = inputs[0].dao.cfg;
         const dbmsByTable = {};
-        await pMap(inputs, async input => {
+        for (const input of inputs) {
             const { dao } = input;
             const { table } = dao.cfg;
             dbmsByTable[table] ||= [];
@@ -879,7 +880,7 @@ export class CommonDao {
                 dao.assignIdCreatedUpdated(row, opt);
                 const dbm = dao.bmToDBM(row, opt);
                 dao.cfg.hooks.beforeSave?.(dbm);
-                const storageRow = await dao.dbmToStorageRow(dbm);
+                const storageRow = dao.dbmToStorageRow(dbm);
                 dbmsByTable[table].push(storageRow);
             }
             else {
@@ -889,10 +890,10 @@ export class CommonDao {
                 if (dao.cfg.hooks.beforeSave) {
                     dbms.forEach(dbm => dao.cfg.hooks.beforeSave(dbm));
                 }
-                const storageRows = await dao.dbmsToStorageRows(dbms);
+                const storageRows = dao.dbmsToStorageRows(dbms);
                 dbmsByTable[table].push(...storageRows);
             }
-        });
+        }
         await db.multiSave(dbmsByTable);
     }
     async createTransaction(opt) {

package/dist/kv/commonKeyValueDao.d.ts

@@ -28,8 +28,8 @@ export interface CommonKeyValueDaoCfg<V> {
 }
 export type CommonKeyValueDaoSaveOptions = CommonKeyValueDBSaveBatchOptions;
 export interface CommonKeyValueDaoTransformer<V> {
-    valueToBuffer: (v: V) => Promise<Buffer>;
-    bufferToValue: (buf: Buffer) => Promise<V>;
+    valueToBuffer: (v: V) => Buffer;
+    bufferToValue: (buf: Buffer) => V;
 }
 /**
  * @deprecated use zstd instead, gzip is obsolete

package/dist/kv/commonKeyValueDao.js

@@ -1,20 +1,19 @@
 import { AppError } from '@naturalcycles/js-lib/error/error.util.js';
-import { pMap } from '@naturalcycles/js-lib/promise/pMap.js';
 import { SKIP } from '@naturalcycles/js-lib/types';
-import { decompressZstdOrInflateToString, deflateString, inflateToString, zstdCompress, zstdDecompressToString, } from '@naturalcycles/nodejs-lib/zip';
+import { zip2 } from '@naturalcycles/nodejs-lib/zip';
 /**
  * @deprecated use zstd instead, gzip is obsolete
  */
 export function commonKeyValueDaoDeflatedJsonTransformer() {
     return {
-        valueToBuffer: async v => await deflateString(JSON.stringify(v)),
-        bufferToValue: async buf => JSON.parse(await inflateToString(buf)),
+        valueToBuffer: v => zip2.deflateSync(JSON.stringify(v)),
+        bufferToValue: buf => JSON.parse(zip2.inflateToStringSync(buf)),
     };
 }
 export function commonKeyValueDaoZstdJsonTransformer(level) {
     return {
-        valueToBuffer: async v => await zstdCompress(JSON.stringify(v), level),
-        bufferToValue: async buf => JSON.parse(await zstdDecompressToString(buf)),
+        valueToBuffer: v => zip2.zstdCompressSync(JSON.stringify(v), level),
+        bufferToValue: buf => JSON.parse(zip2.zstdDecompressToStringSync(buf)),
     };
 }
 /**
@@ -23,8 +22,8 @@ export function commonKeyValueDaoZstdJsonTransformer(level) {
  */
 export function commonKeyValueDaoCompressedTransformer() {
     return {
-        valueToBuffer: async v => await zstdCompress(JSON.stringify(v)),
-        bufferToValue: async buf => JSON.parse(await decompressZstdOrInflateToString(buf)),
+        valueToBuffer: v => zip2.zstdCompressSync(JSON.stringify(v)),
+        bufferToValue: buf => JSON.parse(zip2.decompressZstdOrInflateToStringSync(buf)),
     };
 }
 // todo: logging
@@ -81,10 +80,7 @@ export class CommonKeyValueDao {
         const entries = await this.cfg.db.getByIds(this.cfg.table, ids);
         if (!this.cfg.transformer)
             return entries;
-        return await pMap(entries, async ([id, raw]) => [
-            id,
-            await this.cfg.transformer.bufferToValue(raw),
-        ]);
+        return entries.map(([id, raw]) => [id, this.cfg.transformer.bufferToValue(raw)]);
     }
     async getByIdsAsBuffer(ids) {
         return await this.cfg.db.getByIds(this.cfg.table, ids);
@@ -99,7 +95,7 @@ export class CommonKeyValueDao {
             rawEntries = entries;
         }
         else {
-            rawEntries = await pMap(entries, async ([id, v]) => [id, await transformer.valueToBuffer(v)]);
+            rawEntries = entries.map(([id, v]) => [id, transformer.valueToBuffer(v)]);
         }
         await this.cfg.db.saveBatch(this.cfg.table, rawEntries, opt);
     }
@@ -117,30 +113,30 @@ export class CommonKeyValueDao {
         if (!transformer) {
             return this.cfg.db.streamValues(this.cfg.table, limit);
         }
-        return this.cfg.db.streamValues(this.cfg.table, limit).map(async buf => {
+        return this.cfg.db.streamValues(this.cfg.table, limit).mapSync(buf => {
             try {
-                return await transformer.bufferToValue(buf);
+                return transformer.bufferToValue(buf);
             }
             catch (err) {
                 this.cfg.logger.error(err);
                 return SKIP;
             }
-        }, { concurrency: 32 });
+        });
     }
     streamEntries(limit) {
         const { transformer } = this.cfg;
         if (!transformer) {
             return this.cfg.db.streamEntries(this.cfg.table, limit);
         }
-        return this.cfg.db.streamEntries(this.cfg.table, limit).map(async ([id, buf]) => {
+        return this.cfg.db.streamEntries(this.cfg.table, limit).mapSync(([id, buf]) => {
             try {
-                return [id, await transformer.bufferToValue(buf)];
+                return [id, transformer.bufferToValue(buf)];
             }
             catch (err) {
                 this.cfg.logger.error(err);
                 return SKIP;
             }
-        }, { concurrency: 32 });
+        });
     }
     async getAllKeys(limit) {
         return await this.streamIds(limit).toArray();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/db-lib",
   "type": "module",
-  "version": "10.47.1",
+  "version": "10.49.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@naturalcycles/nodejs-lib": "^15"

package/src/commondao/common.dao.ts

@@ -27,7 +27,7 @@ import type {
 import { stringId } from '@naturalcycles/nodejs-lib'
 import type { JsonSchema } from '@naturalcycles/nodejs-lib/ajv'
 import type { Pipeline } from '@naturalcycles/nodejs-lib/stream'
-import { decompressZstdOrInflateToString, zstdCompress } from '@naturalcycles/nodejs-lib/zip'
+import { zip2 } from '@naturalcycles/nodejs-lib/zip'
 import { DBLibError } from '../cnst.js'
 import type {
   CommonDBSaveOptions,
@@ -155,7 +155,7 @@ export class CommonDao<
     if (!ids.length) return []
     const table = opt.table || this.cfg.table
     const rows = await (opt.tx || this.cfg.db).getByIds<DBM>(table, ids, opt)
-    return await this.storageRowsToDBMs(rows)
+    return this.storageRowsToDBM(rows)
   }
 
   async getBy(by: keyof DBM, value: any, limit = 0, opt?: CommonDaoReadOptions): Promise<BM[]> {
@@ -216,7 +216,7 @@ export class CommonDao<
     q.table = opt.table || q.table
     const { rows: rawRows, ...queryResult } = await this.cfg.db.runQuery<DBM>(q, opt)
     const isPartialQuery = !!q._selectedFieldNames
-    const rows = isPartialQuery ? rawRows : await this.storageRowsToDBMs(rawRows)
+    const rows = isPartialQuery ? rawRows : this.storageRowsToDBM(rawRows)
     const bms = isPartialQuery ? (rows as any[]) : this.dbmsToBM(rows, opt)
     return {
       rows: bms,
@@ -237,7 +237,7 @@ export class CommonDao<
     q.table = opt.table || q.table
     const { rows: rawRows, ...queryResult } = await this.cfg.db.runQuery<DBM>(q, opt)
     const isPartialQuery = !!q._selectedFieldNames
-    const rows = isPartialQuery ? rawRows : await this.storageRowsToDBMs(rawRows)
+    const rows = isPartialQuery ? rawRows : this.storageRowsToDBM(rawRows)
     const dbms = isPartialQuery ? rows : this.anyToDBMs(rows, opt)
     return { rows: dbms, ...queryResult }
   }
@@ -254,10 +254,7 @@ export class CommonDao<
     let pipeline = this.cfg.db.streamQuery<DBM>(q, opt)
 
     if (this.cfg.compress?.keys.length) {
-      pipeline = pipeline.map(async row => await this.storageRowToDBM(row), {
-        // lowered, to reduce the total buffer size a bit for uncompressed objects
-        highWaterMark: 16,
-      })
+      pipeline = pipeline.mapSync(row => this.storageRowToDBM(row))
     }
 
     const isPartialQuery = !!q._selectedFieldNames
@@ -275,10 +272,7 @@ export class CommonDao<
     let pipeline = this.cfg.db.streamQuery<DBM>(q, opt)
 
     if (this.cfg.compress?.keys.length) {
-      pipeline = pipeline.map(async row => await this.storageRowToDBM(row), {
-        // lowered, to reduce the total buffer size a bit for uncompressed objects
-        highWaterMark: 16,
-      })
+      pipeline = pipeline.mapSync(row => this.storageRowToDBM(row))
     }
 
     const isPartialQuery = !!q._selectedFieldNames
@@ -477,7 +471,7 @@ export class CommonDao<
     const table = opt.table || this.cfg.table
     const saveOptions = this.prepareSaveOptions(opt)
 
-    const row = await this.dbmToStorageRow(dbm)
+    const row = this.dbmToStorageRow(dbm)
     await (opt.tx || this.cfg.db).saveBatch(table, [row], saveOptions)
 
     if (saveOptions.assignGeneratedIds) {
@@ -495,7 +489,7 @@ export class CommonDao<
     const table = opt.table || this.cfg.table
     const saveOptions = this.prepareSaveOptions(opt)
 
-    const row = await this.dbmToStorageRow(validDbm)
+    const row = this.dbmToStorageRow(validDbm)
     await (opt.tx || this.cfg.db).saveBatch(table, [row], saveOptions)
 
     if (saveOptions.assignGeneratedIds) {
@@ -516,7 +510,7 @@ export class CommonDao<
     const table = opt.table || this.cfg.table
     const saveOptions = this.prepareSaveOptions(opt)
 
-    const rows = await this.dbmsToStorageRows(dbms)
+    const rows = this.dbmsToStorageRows(dbms)
     await (opt.tx || this.cfg.db).saveBatch(table, rows, saveOptions)
 
     if (saveOptions.assignGeneratedIds) {
@@ -540,7 +534,7 @@ export class CommonDao<
     const table = opt.table || this.cfg.table
     const saveOptions = this.prepareSaveOptions(opt)
 
-    const rows = await this.dbmsToStorageRows(validDbms)
+    const rows = this.dbmsToStorageRows(validDbms)
     await (opt.tx || this.cfg.db).saveBatch(table, rows, saveOptions)
 
     if (saveOptions.assignGeneratedIds) {
@@ -608,7 +602,7 @@ export class CommonDao<
           this.assignIdCreatedUpdated(bm, opt)
           const dbm = this.bmToDBM(bm, opt)
           beforeSave?.(dbm)
-          return await this.dbmToStorageRow(dbm)
+          return this.dbmToStorageRow(dbm)
         },
         { errorMode },
       )
@@ -802,19 +796,23 @@ export class CommonDao<
    * const storageRow = await dao.dbmToStorageRow(dbm)
    * await db.saveBatch(table, [storageRow])
    */
-  async dbmToStorageRow(dbm: DBM): Promise<ObjectWithId> {
+  dbmToStorageRow(dbm: DBM): ObjectWithId {
     if (!this.cfg.compress?.keys.length) return dbm
     const row = { ...dbm }
-    await this.compress(row)
+    this.compress(row)
     return row
   }
 
   /**
    * Converts multiple DBMs to storage rows.
    */
-  async dbmsToStorageRows(dbms: DBM[]): Promise<ObjectWithId[]> {
+  dbmsToStorageRows(dbms: DBM[]): ObjectWithId[] {
     if (!this.cfg.compress?.keys.length) return dbms
-    return await pMap(dbms, async dbm => await this.dbmToStorageRow(dbm))
+    return dbms.map(dbm => {
+      const row = { ...dbm }
+      this.compress(row)
+      return row
+    })
   }
 
   /**
@@ -826,31 +824,35 @@ export class CommonDao<
    * const rows = await db.getByIds(table, ids)
    * const dbms = await Promise.all(rows.map(row => dao.storageRowToDBM(row)))
    */
-  async storageRowToDBM(row: ObjectWithId): Promise<DBM> {
+  storageRowToDBM(row: ObjectWithId): DBM {
     if (!this.cfg.compress?.keys.length) return row as DBM
     const dbm = { ...(row as DBM) }
-    await this.decompress(dbm)
+    this.decompress(dbm)
     return dbm
   }
 
   /**
    * Converts multiple storage rows to DBMs.
    */
-  async storageRowsToDBMs(rows: ObjectWithId[]): Promise<DBM[]> {
+  storageRowsToDBM(rows: ObjectWithId[]): DBM[] {
     if (!this.cfg.compress?.keys.length) return rows as DBM[]
-    return await pMap(rows, async row => await this.storageRowToDBM(row))
+    return rows.map(row => {
+      const dbm = { ...(row as DBM) }
+      this.decompress(dbm)
+      return dbm
+    })
   }
 
   /**
    * Mutates `dbm`.
    */
-  private async compress(dbm: DBM): Promise<void> {
+  private compress(dbm: DBM): void {
     if (!this.cfg.compress?.keys.length) return // No compression requested
 
     const { keys, level = 1 } = this.cfg.compress
     const properties = _pick(dbm, keys)
     const bufferString = JSON.stringify(properties)
-    const __compressed = await zstdCompress(bufferString, level)
+    const __compressed = zip2.zstdCompressSync(bufferString, level)
     _omitWithUndefined(dbm as any, _objectKeys(properties), { mutate: true })
     Object.assign(dbm, { __compressed })
   }
@@ -858,12 +860,11 @@ export class CommonDao<
   /**
    * Mutates `dbm`.
    */
-  private async decompress(dbm: DBM): Promise<void> {
+  private decompress(dbm: DBM): void {
     _typeCast<Compressed<DBM>>(dbm)
     if (!Buffer.isBuffer(dbm.__compressed)) return // No compressed data
 
-    // todo: stop supporting Inflate when we are sure that we have migrated everything to zstd
-    const bufferString = await decompressZstdOrInflateToString(dbm.__compressed)
+    const bufferString = zip2.zstdDecompressToStringSync(dbm.__compressed)
     const properties = JSON.parse(bufferString)
     dbm.__compressed = undefined
     Object.assign(dbm, properties)
@@ -1001,7 +1002,7 @@ export class CommonDao<
 
     const dbmByTableById = CommonDao.multiGetMapByTableById(dbmsByTable)
 
-    return (await CommonDao.prepareMultiGetOutput(inputMap, dbmByTableById, opt)) as any
+    return CommonDao.prepareMultiGetOutput(inputMap, dbmByTableById, opt) as any
   }
 
   private static prepareMultiGetIds(
@@ -1047,22 +1048,22 @@ export class CommonDao<
     return dbmByTableById
   }
 
-  private static async prepareMultiGetOutput(
+  private static prepareMultiGetOutput(
     inputMap: StringMap<DaoWithIds<AnyDao> | DaoWithId<AnyDao>>,
     dbmByTableById: StringMap<StringMap<ObjectWithId>>,
     opt: CommonDaoReadOptions = {},
-  ): Promise<StringMap<unknown>> {
+  ): StringMap<unknown> {
     const bmsByProp: StringMap<unknown> = {}
 
     // Loop over input props again, to produce the output of the same shape as requested
-    await pMap(_stringMapEntries(inputMap), async ([prop, input]) => {
+    for (const [prop, input] of _stringMapEntries(inputMap)) {
       const { dao } = input
       const { table } = dao.cfg
       if ('id' in input) {
         // Singular
         const row = dbmByTableById[table]![input.id]
         // Decompress before converting to BM
-        const dbm = row ? await dao.storageRowToDBM(row) : undefined
+        const dbm = row ? dao.storageRowToDBM(row) : undefined
         bmsByProp[prop] = dao.dbmToBM(dbm, opt) || null
       } else {
         // Plural
@@ -1070,10 +1071,10 @@ export class CommonDao<
         // Without filtering - every prop will get ALL rows from that table.
         const rows = input.ids.map(id => dbmByTableById[table]![id]).filter(_isTruthy)
         // Decompress before converting to BM
-        const dbms = await dao.storageRowsToDBMs(rows)
+        const dbms = dao.storageRowsToDBM(rows)
         bmsByProp[prop] = dao.dbmsToBM(dbms, opt)
       }
-    })
+    }
 
     return bmsByProp as any
   }
@@ -1112,7 +1113,7 @@ export class CommonDao<
     if (!inputs.length) return
     const { db } = inputs[0]!.dao.cfg
     const dbmsByTable: StringMap<any[]> = {}
-    await pMap(inputs, async input => {
+    for (const input of inputs) {
       const { dao } = input
       const { table } = dao.cfg
       dbmsByTable[table] ||= []
@@ -1135,7 +1136,7 @@ export class CommonDao<
         dao.assignIdCreatedUpdated(row, opt)
         const dbm = dao.bmToDBM(row, opt)
         dao.cfg.hooks!.beforeSave?.(dbm)
-        const storageRow = await dao.dbmToStorageRow(dbm)
+        const storageRow = dao.dbmToStorageRow(dbm)
         dbmsByTable[table].push(storageRow)
       } else {
         // Plural
@@ -1144,10 +1145,10 @@ export class CommonDao<
         if (dao.cfg.hooks!.beforeSave) {
           dbms.forEach(dbm => dao.cfg.hooks!.beforeSave!(dbm))
         }
-        const storageRows = await dao.dbmsToStorageRows(dbms)
+        const storageRows = dao.dbmsToStorageRows(dbms)
         dbmsByTable[table].push(...storageRows)
       }
-    })
+    }
 
     await db.multiSave(dbmsByTable)
   }

package/src/kv/commonKeyValueDao.ts

@@ -1,16 +1,9 @@
 import { AppError } from '@naturalcycles/js-lib/error/error.util.js'
 import type { CommonLogger } from '@naturalcycles/js-lib/log'
-import { pMap } from '@naturalcycles/js-lib/promise/pMap.js'
 import { SKIP } from '@naturalcycles/js-lib/types'
 import type { Integer, KeyValueTuple } from '@naturalcycles/js-lib/types'
 import type { Pipeline } from '@naturalcycles/nodejs-lib/stream'
-import {
-  decompressZstdOrInflateToString,
-  deflateString,
-  inflateToString,
-  zstdCompress,
-  zstdDecompressToString,
-} from '@naturalcycles/nodejs-lib/zip'
+import { zip2 } from '@naturalcycles/nodejs-lib/zip'
 import type { CommonDaoLogLevel } from '../commondao/common.dao.model.js'
 import type { CommonDBCreateOptions } from '../db.model.js'
 import type {
@@ -52,8 +45,8 @@ export interface CommonKeyValueDaoCfg<V> {
 export type CommonKeyValueDaoSaveOptions = CommonKeyValueDBSaveBatchOptions
 
 export interface CommonKeyValueDaoTransformer<V> {
-  valueToBuffer: (v: V) => Promise<Buffer>
-  bufferToValue: (buf: Buffer) => Promise<V>
+  valueToBuffer: (v: V) => Buffer
+  bufferToValue: (buf: Buffer) => V
 }
 
 /**
@@ -63,8 +56,8 @@ export function commonKeyValueDaoDeflatedJsonTransformer<
   T = any,
 >(): CommonKeyValueDaoTransformer<T> {
   return {
-    valueToBuffer: async v => await deflateString(JSON.stringify(v)),
-    bufferToValue: async buf => JSON.parse(await inflateToString(buf)),
+    valueToBuffer: v => zip2.deflateSync(JSON.stringify(v)),
+    bufferToValue: buf => JSON.parse(zip2.inflateToStringSync(buf)),
   }
 }
 
@@ -72,8 +65,8 @@ export function commonKeyValueDaoZstdJsonTransformer<T = any>(
   level: Integer | undefined, // defaults to 3
 ): CommonKeyValueDaoTransformer<T> {
   return {
-    valueToBuffer: async v => await zstdCompress(JSON.stringify(v), level),
-    bufferToValue: async buf => JSON.parse(await zstdDecompressToString(buf)),
+    valueToBuffer: v => zip2.zstdCompressSync(JSON.stringify(v), level),
+    bufferToValue: buf => JSON.parse(zip2.zstdDecompressToStringSync(buf)),
   }
 }
 
@@ -83,8 +76,8 @@ export function commonKeyValueDaoZstdJsonTransformer<T = any>(
  */
 export function commonKeyValueDaoCompressedTransformer<T = any>(): CommonKeyValueDaoTransformer<T> {
   return {
-    valueToBuffer: async v => await zstdCompress(JSON.stringify(v)),
-    bufferToValue: async buf => JSON.parse(await decompressZstdOrInflateToString(buf)),
+    valueToBuffer: v => zip2.zstdCompressSync(JSON.stringify(v)),
+    bufferToValue: buf => JSON.parse(zip2.decompressZstdOrInflateToStringSync(buf)),
   }
 }
 
@@ -155,10 +148,7 @@ export class CommonKeyValueDao<K extends string = string, V = Buffer> {
     const entries = await this.cfg.db.getByIds(this.cfg.table, ids)
     if (!this.cfg.transformer) return entries as any
 
-    return await pMap(entries, async ([id, raw]) => [
-      id,
-      await this.cfg.transformer!.bufferToValue(raw),
-    ])
+    return entries.map(([id, raw]) => [id, this.cfg.transformer!.bufferToValue(raw)])
   }
 
   async getByIdsAsBuffer(ids: K[]): Promise<KeyValueDBTuple[]> {
@@ -179,7 +169,7 @@ export class CommonKeyValueDao<K extends string = string, V = Buffer> {
     if (!transformer) {
       rawEntries = entries as any
     } else {
-      rawEntries = await pMap(entries, async ([id, v]) => [id, await transformer.valueToBuffer(v)])
+      rawEntries = entries.map(([id, v]) => [id, transformer.valueToBuffer(v)])
     }
 
     await this.cfg.db.saveBatch(this.cfg.table, rawEntries, opt)
@@ -204,17 +194,14 @@ export class CommonKeyValueDao<K extends string = string, V = Buffer> {
       return this.cfg.db.streamValues(this.cfg.table, limit) as Pipeline<V>
     }
 
-    return this.cfg.db.streamValues(this.cfg.table, limit).map(
-      async buf => {
-        try {
-          return await transformer.bufferToValue(buf)
-        } catch (err) {
-          this.cfg.logger.error(err)
-          return SKIP
-        }
-      },
-      { concurrency: 32 },
-    )
+    return this.cfg.db.streamValues(this.cfg.table, limit).mapSync(buf => {
+      try {
+        return transformer.bufferToValue(buf)
+      } catch (err) {
+        this.cfg.logger.error(err)
+        return SKIP
+      }
+    })
   }
 
   streamEntries(limit?: number): Pipeline<KeyValueTuple<K, V>> {
@@ -224,17 +211,14 @@ export class CommonKeyValueDao<K extends string = string, V = Buffer> {
       return this.cfg.db.streamEntries(this.cfg.table, limit) as Pipeline<KeyValueTuple<K, V>>
     }
 
-    return this.cfg.db.streamEntries(this.cfg.table, limit).map(
-      async ([id, buf]) => {
-        try {
-          return [id as K, await transformer.bufferToValue(buf)]
-        } catch (err) {
-          this.cfg.logger.error(err)
-          return SKIP
-        }
-      },
-      { concurrency: 32 },
-    )
+    return this.cfg.db.streamEntries(this.cfg.table, limit).mapSync(([id, buf]) => {
+      try {
+        return [id as K, transformer.bufferToValue(buf)]
+      } catch (err) {
+        this.cfg.logger.error(err)
+        return SKIP
+      }
+    })
   }
 
   async getAllKeys(limit?: number): Promise<K[]> {