@naturalcycles/db-lib 10.45.2 → 10.46.1

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

@@ -123,16 +123,16 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * @experimental
      */
     incrementBatch(prop: keyof DBM, incrementMap: StringMap<number>, opt?: CommonDaoOptions): Promise<StringMap<number>>;
-    dbmToBM(_dbm: undefined, opt?: CommonDaoOptions): Promise<null>;
-    dbmToBM(_dbm?: DBM, opt?: CommonDaoOptions): Promise<BM>;
-    dbmsToBM(dbms: DBM[], opt?: CommonDaoOptions): Promise<BM[]>;
+    dbmToBM(_dbm: undefined, opt?: CommonDaoOptions): null;
+    dbmToBM(_dbm?: DBM, opt?: CommonDaoOptions): BM;
+    dbmsToBM(dbms: DBM[], opt?: CommonDaoOptions): BM[];
     /**
      * Mutates object with properties: id, created, updated.
      * Returns DBM (new reference).
      */
-    bmToDBM(bm: undefined, opt?: CommonDaoOptions): Promise<null>;
-    bmToDBM(bm?: BM, opt?: CommonDaoOptions): Promise<DBM>;
-    bmsToDBM(bms: BM[], opt?: CommonDaoOptions): Promise<DBM[]>;
+    bmToDBM(bm: undefined, opt?: CommonDaoOptions): null;
+    bmToDBM(bm?: BM, opt?: CommonDaoOptions): DBM;
+    bmsToDBM(bms: BM[], opt?: CommonDaoOptions): DBM[];
     /**
      * Converts a DBM to storage format, applying compression if configured.
      *
@@ -164,9 +164,9 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     storageRowsToDBMs(rows: ObjectWithId[]): Promise<DBM[]>;
     private compress;
     private decompress;
-    anyToDBM(dbm: undefined, opt?: CommonDaoOptions): Promise<null>;
-    anyToDBM(dbm?: any, opt?: CommonDaoOptions): Promise<DBM>;
-    anyToDBMs(rows: DBM[], opt?: CommonDaoOptions): Promise<DBM[]>;
+    anyToDBM(dbm: undefined, opt?: CommonDaoOptions): null;
+    anyToDBM(dbm?: any, opt?: CommonDaoOptions): DBM;
+    anyToDBMs(rows: DBM[], opt?: CommonDaoOptions): DBM[];
     /**
      * Returns *converted value* (NOT the same reference).
      * Does NOT mutate the object.
@@ -183,43 +183,6 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     withIds(ids: ID[]): DaoWithIds<CommonDao<BM, DBM, ID>>;
     withRowsToSave(rows: Unsaved<BM>[]): DaoWithRows<CommonDao<BM, DBM, ID>>;
     withRowToSave(row: Unsaved<BM>, opt?: DaoWithRowOptions<BM>): DaoWithRow<CommonDao<BM, DBM, ID>>;
-    /**
-     * Helper to decompress legacy compressed data when migrating away from auto-compression.
-     * Use as your `beforeDBMToBM` hook to decompress legacy rows on read.
-     *
-     * @example
-     * const dao = new CommonDao({
-     *   hooks: {
-     *     beforeDBMToBM: CommonDao.decompressLegacyRow,
-     *   }
-     * })
-     *
-     * // Or within an existing hook:
-     * beforeDBMToBM: async (dbm) => {
-     *   await CommonDao.decompressLegacyRow(dbm)
-     *   // ... other transformations
-     *   return dbm
-     * }
-     */
-    static decompressLegacyRow<T extends ObjectWithId>(this: void, row: T): Promise<T>;
-    /**
-     * Temporary helper to migrate from the old `data` compressed property to the new `__compressed` property.
-     * Use as your `beforeDBMToBM` hook during the migration period.
-     *
-     * Migration steps:
-     * 1. Add `beforeDBMToBM: CommonDao.migrateCompressedDataProperty` to your hooks
-     * 2. Deploy - old data (with `data` property) will be decompressed on read and recompressed to `__compressed` on write
-     * 3. Once all data has been naturally rewritten, remove the hook
-     *
-     * @example
-     * const dao = new CommonDao({
-     *   compress: { keys: ['field1', 'field2'] },
-     *   hooks: {
-     *     beforeDBMToBM: CommonDao.migrateCompressedDataProperty,
-     *   }
-     * })
-     */
-    static migrateCompressedDataProperty<T extends ObjectWithId>(row: T): Promise<T>;
     /**
      * Load rows (by their ids) from Multiple tables at once.
      * An optimized way to load data, minimizing DB round-trips.

package/dist/commondao/common.dao.js

@@ -83,21 +83,21 @@ export class CommonDao {
         if (!id)
             return null;
         const [dbm] = await this.loadByIds([id], opt);
-        return await this.dbmToBM(dbm, opt);
+        return this.dbmToBM(dbm, opt);
     }
     async getByIdAsDBM(id, opt = {}) {
         if (!id)
             return null;
         const [row] = await this.loadByIds([id], opt);
-        return await this.anyToDBM(row, opt);
+        return this.anyToDBM(row, opt);
     }
     async getByIds(ids, opt = {}) {
         const dbms = await this.loadByIds(ids, opt);
-        return await this.dbmsToBM(dbms, opt);
+        return this.dbmsToBM(dbms, opt);
     }
     async getByIdsAsDBM(ids, opt = {}) {
         const rows = await this.loadByIds(ids, opt);
-        return await this.anyToDBMs(rows);
+        return this.anyToDBMs(rows);
     }
     // DRY private method
     async loadByIds(ids, opt = {}) {
@@ -149,7 +149,7 @@ export class CommonDao {
         const { rows: rawRows, ...queryResult } = await this.cfg.db.runQuery(q, opt);
         const isPartialQuery = !!q._selectedFieldNames;
         const rows = isPartialQuery ? rawRows : await this.storageRowsToDBMs(rawRows);
-        const bms = isPartialQuery ? rows : await this.dbmsToBM(rows, opt);
+        const bms = isPartialQuery ? rows : this.dbmsToBM(rows, opt);
         return {
             rows: bms,
             ...queryResult,
@@ -165,7 +165,7 @@ export class CommonDao {
         const { rows: rawRows, ...queryResult } = await this.cfg.db.runQuery(q, opt);
         const isPartialQuery = !!q._selectedFieldNames;
         const rows = isPartialQuery ? rawRows : await this.storageRowsToDBMs(rawRows);
-        const dbms = isPartialQuery ? rows : await this.anyToDBMs(rows, opt);
+        const dbms = isPartialQuery ? rows : this.anyToDBMs(rows, opt);
         return { rows: dbms, ...queryResult };
     }
     async runQueryCount(q, opt = {}) {
@@ -185,7 +185,7 @@ export class CommonDao {
             return pipeline;
         opt.skipValidation ??= true;
         opt.errorMode ||= ErrorMode.SUPPRESS;
-        return pipeline.map(async dbm => await this.anyToDBM(dbm, opt), { errorMode: opt.errorMode });
+        return pipeline.mapSync(dbm => this.anyToDBM(dbm, opt), { errorMode: opt.errorMode });
     }
     streamQuery(q, opt = {}) {
         this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
@@ -199,7 +199,7 @@ export class CommonDao {
             return pipeline;
         opt.skipValidation ??= true;
         opt.errorMode ||= ErrorMode.SUPPRESS;
-        return pipeline.map(async dbm => await this.dbmToBM(dbm, opt), { errorMode: opt.errorMode });
+        return pipeline.mapSync(dbm => this.dbmToBM(dbm, opt), { errorMode: opt.errorMode });
     }
     async queryIds(q, opt = {}) {
         this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
@@ -347,7 +347,7 @@ export class CommonDao {
         }
         this.assignIdCreatedUpdated(bm, opt); // mutates
         _typeCast(bm);
-        const dbm = await this.bmToDBM(bm, opt); // validates BM
+        const dbm = this.bmToDBM(bm, opt); // validates BM
         this.cfg.hooks.beforeSave?.(dbm);
         const table = opt.table || this.cfg.table;
         const saveOptions = this.prepareSaveOptions(opt);
@@ -361,7 +361,7 @@ export class CommonDao {
     async saveAsDBM(dbm, opt = {}) {
         this.requireWriteAccess();
         this.assignIdCreatedUpdated(dbm, opt); // mutates
-        const validDbm = await this.anyToDBM(dbm, opt);
+        const validDbm = this.anyToDBM(dbm, opt);
         this.cfg.hooks.beforeSave?.(validDbm);
         const table = opt.table || this.cfg.table;
         const saveOptions = this.prepareSaveOptions(opt);
@@ -377,7 +377,7 @@ export class CommonDao {
             return [];
         this.requireWriteAccess();
         bms.forEach(bm => this.assignIdCreatedUpdated(bm, opt));
-        const dbms = await this.bmsToDBM(bms, opt);
+        const dbms = this.bmsToDBM(bms, opt);
         if (this.cfg.hooks.beforeSave) {
             dbms.forEach(dbm => this.cfg.hooks.beforeSave(dbm));
         }
@@ -395,7 +395,7 @@ export class CommonDao {
             return [];
         this.requireWriteAccess();
         dbms.forEach(dbm => this.assignIdCreatedUpdated(dbm, opt));
-        const validDbms = await this.anyToDBMs(dbms, opt);
+        const validDbms = this.anyToDBMs(dbms, opt);
         if (this.cfg.hooks.beforeSave) {
             validDbms.forEach(dbm => this.cfg.hooks.beforeSave(dbm));
         }
@@ -449,7 +449,7 @@ export class CommonDao {
         await p
             .map(async bm => {
             this.assignIdCreatedUpdated(bm, opt);
-            const dbm = await this.bmToDBM(bm, opt);
+            const dbm = this.bmToDBM(bm, opt);
             beforeSave?.(dbm);
             return await this.dbmToStorageRow(dbm);
         }, { errorMode })
@@ -560,32 +560,31 @@ export class CommonDao {
         const { table } = this.cfg;
         return await this.cfg.db.incrementBatch(table, prop, incrementMap);
     }
-    async dbmToBM(_dbm, opt = {}) {
+    dbmToBM(_dbm, opt = {}) {
         if (!_dbm)
             return null;
         // optimization: no need to run full joi DBM validation, cause BM validation will be run
         // const dbm = this.anyToDBM(_dbm, opt)
         const dbm = { ..._dbm, ...this.cfg.hooks.parseNaturalId(_dbm.id) };
         // DBM > BM
-        const bm = ((await this.cfg.hooks.beforeDBMToBM?.(dbm)) || dbm);
+        const bm = (this.cfg.hooks.beforeDBMToBM?.(dbm) || dbm);
         // Validate/convert BM
         return this.validateAndConvert(bm, 'load', opt);
     }
-    async dbmsToBM(dbms, opt = {}) {
-        return await pMap(dbms, async dbm => await this.dbmToBM(dbm, opt));
+    dbmsToBM(dbms, opt = {}) {
+        return dbms.map(dbm => this.dbmToBM(dbm, opt));
     }
-    async bmToDBM(bm, opt) {
+    bmToDBM(bm, opt) {
         if (bm === undefined)
             return null;
         // bm gets assigned to the new reference
         bm = this.validateAndConvert(bm, 'save', opt);
         // BM > DBM
-        const dbm = ((await this.cfg.hooks.beforeBMToDBM?.(bm)) || bm);
+        const dbm = (this.cfg.hooks.beforeBMToDBM?.(bm) || bm);
         return dbm;
     }
-    async bmsToDBM(bms, opt = {}) {
-        // try/catch?
-        return await pMap(bms, async bm => await this.bmToDBM(bm, opt));
+    bmsToDBM(bms, opt = {}) {
+        return bms.map(bm => this.bmToDBM(bm, opt));
     }
     // STORAGE LAYER (compression/decompression at DB boundary)
     // These methods convert between DBM (logical model) and storage format (physical, possibly compressed).
@@ -660,15 +659,13 @@ export class CommonDao {
         _typeCast(dbm);
         if (!Buffer.isBuffer(dbm.__compressed))
             return; // No compressed data
-        try {
-            const bufferString = await decompressZstdOrInflateToString(dbm.__compressed);
-            const properties = JSON.parse(bufferString);
-            dbm.__compressed = undefined;
-            Object.assign(dbm, properties);
-        }
-        catch { }
+        // todo: stop supporting Inflate when we are sure that we have migrated everything to zstd
+        const bufferString = await decompressZstdOrInflateToString(dbm.__compressed);
+        const properties = JSON.parse(bufferString);
+        dbm.__compressed = undefined;
+        Object.assign(dbm, properties);
     }
-    async anyToDBM(dbm, _opt = {}) {
+    anyToDBM(dbm, _opt = {}) {
         if (!dbm)
             return null;
         // this shouldn't be happening on load! but should on save!
@@ -678,8 +675,8 @@ export class CommonDao {
         // return this.validateAndConvert(dbm, this.cfg.dbmSchema, DBModelType.DBM, opt)
         return dbm;
     }
-    async anyToDBMs(rows, opt = {}) {
-        return await pMap(rows, async entity => await this.anyToDBM(entity, opt));
+    anyToDBMs(rows, opt = {}) {
+        return rows.map(entity => this.anyToDBM(entity, opt));
     }
     /**
      * Returns *converted value* (NOT the same reference).
@@ -751,73 +748,6 @@ export class CommonDao {
             opt: opt,
         };
     }
-    /**
-     * Helper to decompress legacy compressed data when migrating away from auto-compression.
-     * Use as your `beforeDBMToBM` hook to decompress legacy rows on read.
-     *
-     * @example
-     * const dao = new CommonDao({
-     *   hooks: {
-     *     beforeDBMToBM: CommonDao.decompressLegacyRow,
-     *   }
-     * })
-     *
-     * // Or within an existing hook:
-     * beforeDBMToBM: async (dbm) => {
-     *   await CommonDao.decompressLegacyRow(dbm)
-     *   // ... other transformations
-     *   return dbm
-     * }
-     */
-    static async decompressLegacyRow(row) {
-        // Check both __compressed (current) and data (legacy) for backward compatibility
-        const compressed = row.__compressed ?? row.data;
-        if (!Buffer.isBuffer(compressed))
-            return row;
-        try {
-            const bufferString = await decompressZstdOrInflateToString(compressed);
-            const properties = JSON.parse(bufferString);
-            row.__compressed = undefined;
-            row.data = undefined;
-            Object.assign(row, properties);
-        }
-        catch {
-            // Decompression failed - field is not compressed, leave as-is
-        }
-        return row;
-    }
-    /**
-     * Temporary helper to migrate from the old `data` compressed property to the new `__compressed` property.
-     * Use as your `beforeDBMToBM` hook during the migration period.
-     *
-     * Migration steps:
-     * 1. Add `beforeDBMToBM: CommonDao.migrateCompressedDataProperty` to your hooks
-     * 2. Deploy - old data (with `data` property) will be decompressed on read and recompressed to `__compressed` on write
-     * 3. Once all data has been naturally rewritten, remove the hook
-     *
-     * @example
-     * const dao = new CommonDao({
-     *   compress: { keys: ['field1', 'field2'] },
-     *   hooks: {
-     *     beforeDBMToBM: CommonDao.migrateCompressedDataProperty,
-     *   }
-     * })
-     */
-    static async migrateCompressedDataProperty(row) {
-        const data = row.data;
-        if (!Buffer.isBuffer(data))
-            return row;
-        try {
-            const bufferString = await decompressZstdOrInflateToString(data);
-            const properties = JSON.parse(bufferString);
-            row.data = undefined;
-            Object.assign(row, properties);
-        }
-        catch {
-            // Decompression failed - data field is not compressed, leave as-is
-        }
-        return row;
-    }
     /**
      * Load rows (by their ids) from Multiple tables at once.
      * An optimized way to load data, minimizing DB round-trips.
@@ -881,7 +811,7 @@ export class CommonDao {
                 const row = dbmByTableById[table][input.id];
                 // Decompress before converting to BM
                 const dbm = row ? await dao.storageRowToDBM(row) : undefined;
-                bmsByProp[prop] = (await dao.dbmToBM(dbm, opt)) || null;
+                bmsByProp[prop] = dao.dbmToBM(dbm, opt) || null;
             }
             else {
                 // Plural
@@ -890,7 +820,7 @@ export class CommonDao {
                 const rows = input.ids.map(id => dbmByTableById[table][id]).filter(_isTruthy);
                 // Decompress before converting to BM
                 const dbms = await dao.storageRowsToDBMs(rows);
-                bmsByProp[prop] = await dao.dbmsToBM(dbms, opt);
+                bmsByProp[prop] = dao.dbmsToBM(dbms, opt);
             }
         });
         return bmsByProp;
@@ -941,7 +871,7 @@ export class CommonDao {
                     }
                 }
                 dao.assignIdCreatedUpdated(row, opt);
-                const dbm = await dao.bmToDBM(row, opt);
+                const dbm = dao.bmToDBM(row, opt);
                 dao.cfg.hooks.beforeSave?.(dbm);
                 const storageRow = await dao.dbmToStorageRow(dbm);
                 dbmsByTable[table].push(storageRow);
@@ -949,7 +879,7 @@ export class CommonDao {
             else {
                 // Plural
                 input.rows.forEach(bm => dao.assignIdCreatedUpdated(bm, opt));
-                const dbms = await dao.bmsToDBM(input.rows, opt);
+                const dbms = dao.bmsToDBM(input.rows, opt);
                 if (dao.cfg.hooks.beforeSave) {
                     dbms.forEach(dbm => dao.cfg.hooks.beforeSave(dbm));
                 }

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

@@ -31,8 +31,8 @@ export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntit
      * - patch, patchAsDBM
      */
     beforeCreate: (bm: Partial<BM>) => Partial<BM>;
-    beforeDBMToBM: (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>;
-    beforeBMToDBM: (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>;
+    beforeDBMToBM: (dbm: DBM) => Partial<BM>;
+    beforeBMToDBM: (bm: BM) => Partial<DBM>;
     /**
      * Allows to access the DBM just after it has been loaded from the DB.
      *

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@naturalcycles/db-lib",
   "type": "module",
-  "version": "10.45.2",
+  "version": "10.46.1",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@naturalcycles/nodejs-lib": "^15"
   },
   "devDependencies": {
-    "@typescript/native-preview": "7.0.0-dev.20260201.1",
+    "@typescript/native-preview": "7.0.0-dev.20260301.1",
     "@naturalcycles/dev-lib": "18.4.2"
   },
   "files": [

package/src/commondao/common.dao.model.ts

@@ -40,8 +40,8 @@ export interface CommonDaoHooks<
    */
   beforeCreate: (bm: Partial<BM>) => Partial<BM>
 
-  beforeDBMToBM: (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>
-  beforeBMToDBM: (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>
+  beforeDBMToBM: (dbm: DBM) => Partial<BM>
+  beforeBMToDBM: (bm: BM) => Partial<DBM>
 
   /**
    * Allows to access the DBM just after it has been loaded from the DB.

package/src/commondao/common.dao.ts

@@ -131,23 +131,23 @@ export class CommonDao<
   async getById(id?: ID | null, opt: CommonDaoReadOptions = {}): Promise<BM | null> {
     if (!id) return null
     const [dbm] = await this.loadByIds([id], opt)
-    return await this.dbmToBM(dbm, opt)
+    return this.dbmToBM(dbm, opt)
   }
 
   async getByIdAsDBM(id?: ID | null, opt: CommonDaoReadOptions = {}): Promise<DBM | null> {
     if (!id) return null
     const [row] = await this.loadByIds([id], opt)
-    return await this.anyToDBM(row, opt)
+    return this.anyToDBM(row, opt)
   }
 
   async getByIds(ids: ID[], opt: CommonDaoReadOptions = {}): Promise<BM[]> {
     const dbms = await this.loadByIds(ids, opt)
-    return await this.dbmsToBM(dbms, opt)
+    return this.dbmsToBM(dbms, opt)
   }
 
   async getByIdsAsDBM(ids: ID[], opt: CommonDaoReadOptions = {}): Promise<DBM[]> {
     const rows = await this.loadByIds(ids, opt)
-    return await this.anyToDBMs(rows)
+    return this.anyToDBMs(rows)
   }
 
   // DRY private method
@@ -217,7 +217,7 @@ export class CommonDao<
     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 bms = isPartialQuery ? (rows as any[]) : await this.dbmsToBM(rows, opt)
+    const bms = isPartialQuery ? (rows as any[]) : this.dbmsToBM(rows, opt)
     return {
       rows: bms,
       ...queryResult,
@@ -238,7 +238,7 @@ export class CommonDao<
     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 dbms = isPartialQuery ? rows : await this.anyToDBMs(rows, opt)
+    const dbms = isPartialQuery ? rows : this.anyToDBMs(rows, opt)
     return { rows: dbms, ...queryResult }
   }
 
@@ -263,7 +263,7 @@ export class CommonDao<
     opt.skipValidation ??= true
     opt.errorMode ||= ErrorMode.SUPPRESS
 
-    return pipeline.map(async dbm => await this.anyToDBM(dbm, opt), { errorMode: opt.errorMode })
+    return pipeline.mapSync(dbm => this.anyToDBM(dbm, opt), { errorMode: opt.errorMode })
   }
 
   streamQuery(q: DBQuery<DBM>, opt: CommonDaoStreamOptions<BM> = {}): Pipeline<BM> {
@@ -281,7 +281,7 @@ export class CommonDao<
     opt.skipValidation ??= true
     opt.errorMode ||= ErrorMode.SUPPRESS
 
-    return pipeline.map(async dbm => await this.dbmToBM(dbm, opt), { errorMode: opt.errorMode })
+    return pipeline.mapSync(dbm => this.dbmToBM(dbm, opt), { errorMode: opt.errorMode })
   }
 
   async queryIds(q: DBQuery<DBM>, opt: CommonDaoReadOptions = {}): Promise<ID[]> {
@@ -466,7 +466,7 @@ export class CommonDao<
 
     this.assignIdCreatedUpdated(bm, opt) // mutates
     _typeCast<BM>(bm)
-    const dbm = await this.bmToDBM(bm, opt) // validates BM
+    const dbm = this.bmToDBM(bm, opt) // validates BM
     this.cfg.hooks!.beforeSave?.(dbm)
     const table = opt.table || this.cfg.table
     const saveOptions = this.prepareSaveOptions(opt)
@@ -484,7 +484,7 @@ export class CommonDao<
   async saveAsDBM(dbm: Unsaved<DBM>, opt: CommonDaoSaveOptions<BM, DBM> = {}): Promise<DBM> {
     this.requireWriteAccess()
     this.assignIdCreatedUpdated(dbm, opt) // mutates
-    const validDbm = await this.anyToDBM(dbm, opt)
+    const validDbm = this.anyToDBM(dbm, opt)
     this.cfg.hooks!.beforeSave?.(validDbm)
     const table = opt.table || this.cfg.table
     const saveOptions = this.prepareSaveOptions(opt)
@@ -503,7 +503,7 @@ export class CommonDao<
     if (!bms.length) return []
     this.requireWriteAccess()
     bms.forEach(bm => this.assignIdCreatedUpdated(bm, opt))
-    const dbms = await this.bmsToDBM(bms as BM[], opt)
+    const dbms = this.bmsToDBM(bms as BM[], opt)
     if (this.cfg.hooks!.beforeSave) {
       dbms.forEach(dbm => this.cfg.hooks!.beforeSave!(dbm))
     }
@@ -527,7 +527,7 @@ export class CommonDao<
     if (!dbms.length) return []
     this.requireWriteAccess()
     dbms.forEach(dbm => this.assignIdCreatedUpdated(dbm, opt))
-    const validDbms = await this.anyToDBMs(dbms as DBM[], opt)
+    const validDbms = this.anyToDBMs(dbms as DBM[], opt)
     if (this.cfg.hooks!.beforeSave) {
       validDbms.forEach(dbm => this.cfg.hooks!.beforeSave!(dbm))
     }
@@ -600,7 +600,7 @@ export class CommonDao<
       .map(
         async bm => {
           this.assignIdCreatedUpdated(bm, opt)
-          const dbm = await this.bmToDBM(bm, opt)
+          const dbm = this.bmToDBM(bm, opt)
           beforeSave?.(dbm)
           return await this.dbmToStorageRow(dbm)
         },
@@ -739,9 +739,9 @@ export class CommonDao<
 
   // CONVERSIONS
 
-  async dbmToBM(_dbm: undefined, opt?: CommonDaoOptions): Promise<null>
-  async dbmToBM(_dbm?: DBM, opt?: CommonDaoOptions): Promise<BM>
-  async dbmToBM(_dbm?: DBM, opt: CommonDaoOptions = {}): Promise<BM | null> {
+  dbmToBM(_dbm: undefined, opt?: CommonDaoOptions): null
+  dbmToBM(_dbm?: DBM, opt?: CommonDaoOptions): BM
+  dbmToBM(_dbm?: DBM, opt: CommonDaoOptions = {}): BM | null {
     if (!_dbm) return null
 
     // optimization: no need to run full joi DBM validation, cause BM validation will be run
@@ -749,37 +749,36 @@ export class CommonDao<
     const dbm: DBM = { ..._dbm, ...this.cfg.hooks!.parseNaturalId!(_dbm.id as ID) }
 
     // DBM > BM
-    const bm = ((await this.cfg.hooks!.beforeDBMToBM?.(dbm)) || dbm) as Partial<BM>
+    const bm = (this.cfg.hooks!.beforeDBMToBM?.(dbm) || dbm) as Partial<BM>
 
     // Validate/convert BM
     return this.validateAndConvert(bm, 'load', opt)
   }
 
-  async dbmsToBM(dbms: DBM[], opt: CommonDaoOptions = {}): Promise<BM[]> {
-    return await pMap(dbms, async dbm => await this.dbmToBM(dbm, opt))
+  dbmsToBM(dbms: DBM[], opt: CommonDaoOptions = {}): BM[] {
+    return dbms.map(dbm => this.dbmToBM(dbm, opt))
   }
 
   /**
    * Mutates object with properties: id, created, updated.
    * Returns DBM (new reference).
    */
-  async bmToDBM(bm: undefined, opt?: CommonDaoOptions): Promise<null>
-  async bmToDBM(bm?: BM, opt?: CommonDaoOptions): Promise<DBM>
-  async bmToDBM(bm?: BM, opt?: CommonDaoOptions): Promise<DBM | null> {
+  bmToDBM(bm: undefined, opt?: CommonDaoOptions): null
+  bmToDBM(bm?: BM, opt?: CommonDaoOptions): DBM
+  bmToDBM(bm?: BM, opt?: CommonDaoOptions): DBM | null {
     if (bm === undefined) return null
 
     // bm gets assigned to the new reference
     bm = this.validateAndConvert(bm, 'save', opt)
 
     // BM > DBM
-    const dbm = ((await this.cfg.hooks!.beforeBMToDBM?.(bm)) || bm) as DBM
+    const dbm = (this.cfg.hooks!.beforeBMToDBM?.(bm) || bm) as DBM
 
     return dbm
   }
 
-  async bmsToDBM(bms: BM[], opt: CommonDaoOptions = {}): Promise<DBM[]> {
-    // try/catch?
-    return await pMap(bms, async bm => await this.bmToDBM(bm, opt))
+  bmsToDBM(bms: BM[], opt: CommonDaoOptions = {}): DBM[] {
+    return bms.map(bm => this.bmToDBM(bm, opt))
   }
 
   // STORAGE LAYER (compression/decompression at DB boundary)
@@ -857,17 +856,16 @@ export class CommonDao<
     _typeCast<Compressed<DBM>>(dbm)
     if (!Buffer.isBuffer(dbm.__compressed)) return // No compressed data
 
-    try {
-      const bufferString = await decompressZstdOrInflateToString(dbm.__compressed)
-      const properties = JSON.parse(bufferString)
-      dbm.__compressed = undefined
-      Object.assign(dbm, properties)
-    } catch {}
+    // todo: stop supporting Inflate when we are sure that we have migrated everything to zstd
+    const bufferString = await decompressZstdOrInflateToString(dbm.__compressed)
+    const properties = JSON.parse(bufferString)
+    dbm.__compressed = undefined
+    Object.assign(dbm, properties)
   }
 
-  async anyToDBM(dbm: undefined, opt?: CommonDaoOptions): Promise<null>
-  async anyToDBM(dbm?: any, opt?: CommonDaoOptions): Promise<DBM>
-  async anyToDBM(dbm?: DBM, _opt: CommonDaoOptions = {}): Promise<DBM | null> {
+  anyToDBM(dbm: undefined, opt?: CommonDaoOptions): null
+  anyToDBM(dbm?: any, opt?: CommonDaoOptions): DBM
+  anyToDBM(dbm?: DBM, _opt: CommonDaoOptions = {}): DBM | null {
     if (!dbm) return null
 
     // this shouldn't be happening on load! but should on save!
@@ -880,8 +878,8 @@ export class CommonDao<
     return dbm
   }
 
-  async anyToDBMs(rows: DBM[], opt: CommonDaoOptions = {}): Promise<DBM[]> {
-    return await pMap(rows, async entity => await this.anyToDBM(entity, opt))
+  anyToDBMs(rows: DBM[], opt: CommonDaoOptions = {}): DBM[] {
+    return rows.map(entity => this.anyToDBM(entity, opt))
   }
 
   /**
@@ -971,75 +969,6 @@ export class CommonDao<
     }
   }
 
-  /**
-   * Helper to decompress legacy compressed data when migrating away from auto-compression.
-   * Use as your `beforeDBMToBM` hook to decompress legacy rows on read.
-   *
-   * @example
-   * const dao = new CommonDao({
-   *   hooks: {
-   *     beforeDBMToBM: CommonDao.decompressLegacyRow,
-   *   }
-   * })
-   *
-   * // Or within an existing hook:
-   * beforeDBMToBM: async (dbm) => {
-   *   await CommonDao.decompressLegacyRow(dbm)
-   *   // ... other transformations
-   *   return dbm
-   * }
-   */
-  static async decompressLegacyRow<T extends ObjectWithId>(this: void, row: T): Promise<T> {
-    // Check both __compressed (current) and data (legacy) for backward compatibility
-    const compressed = (row as any).__compressed ?? (row as any).data
-    if (!Buffer.isBuffer(compressed)) return row
-
-    try {
-      const bufferString = await decompressZstdOrInflateToString(compressed)
-      const properties = JSON.parse(bufferString)
-      ;(row as any).__compressed = undefined
-      ;(row as any).data = undefined
-      Object.assign(row, properties)
-    } catch {
-      // Decompression failed - field is not compressed, leave as-is
-    }
-
-    return row
-  }
-
-  /**
-   * Temporary helper to migrate from the old `data` compressed property to the new `__compressed` property.
-   * Use as your `beforeDBMToBM` hook during the migration period.
-   *
-   * Migration steps:
-   * 1. Add `beforeDBMToBM: CommonDao.migrateCompressedDataProperty` to your hooks
-   * 2. Deploy - old data (with `data` property) will be decompressed on read and recompressed to `__compressed` on write
-   * 3. Once all data has been naturally rewritten, remove the hook
-   *
-   * @example
-   * const dao = new CommonDao({
-   *   compress: { keys: ['field1', 'field2'] },
-   *   hooks: {
-   *     beforeDBMToBM: CommonDao.migrateCompressedDataProperty,
-   *   }
-   * })
-   */
-  static async migrateCompressedDataProperty<T extends ObjectWithId>(row: T): Promise<T> {
-    const data = (row as any).data
-    if (!Buffer.isBuffer(data)) return row
-
-    try {
-      const bufferString = await decompressZstdOrInflateToString(data)
-      const properties = JSON.parse(bufferString)
-      ;(row as any).data = undefined
-      Object.assign(row, properties)
-    } catch {
-      // Decompression failed - data field is not compressed, leave as-is
-    }
-
-    return row
-  }
-
   /**
    * Load rows (by their ids) from Multiple tables at once.
    * An optimized way to load data, minimizing DB round-trips.
@@ -1128,7 +1057,7 @@ export class CommonDao<
         const row = dbmByTableById[table]![input.id]
         // Decompress before converting to BM
         const dbm = row ? await dao.storageRowToDBM(row) : undefined
-        bmsByProp[prop] = (await dao.dbmToBM(dbm, opt)) || null
+        bmsByProp[prop] = dao.dbmToBM(dbm, opt) || null
       } else {
         // Plural
         // We apply filtering, to be able to support multiple input props fetching from the same table.
@@ -1136,7 +1065,7 @@ export class CommonDao<
         const rows = input.ids.map(id => dbmByTableById[table]![id]).filter(_isTruthy)
         // Decompress before converting to BM
         const dbms = await dao.storageRowsToDBMs(rows)
-        bmsByProp[prop] = await dao.dbmsToBM(dbms, opt)
+        bmsByProp[prop] = dao.dbmsToBM(dbms, opt)
       }
     })
 
@@ -1198,14 +1127,14 @@ export class CommonDao<
         }
 
         dao.assignIdCreatedUpdated(row, opt)
-        const dbm = await dao.bmToDBM(row, opt)
+        const dbm = dao.bmToDBM(row, opt)
         dao.cfg.hooks!.beforeSave?.(dbm)
         const storageRow = await dao.dbmToStorageRow(dbm)
         dbmsByTable[table].push(storageRow)
       } else {
         // Plural
         input.rows.forEach(bm => dao.assignIdCreatedUpdated(bm, opt))
-        const dbms = await dao.bmsToDBM(input.rows, opt)
+        const dbms = dao.bmsToDBM(input.rows, opt)
         if (dao.cfg.hooks!.beforeSave) {
           dbms.forEach(dbm => dao.cfg.hooks!.beforeSave!(dbm))
         }