@naturalcycles/db-lib 9.6.0 → 9.7.1

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

@@ -19,7 +19,6 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     getById(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
     getById(id?: string | null, opt?: CommonDaoOptions): Promise<BM | null>;
     getByIdOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<BM>;
-    getByIdAsDBMOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<DBM>;
     getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
     getByIdAsDBM(id?: string | null, opt?: CommonDaoOptions): Promise<DBM | null>;
     getByIds(ids: string[], opt?: CommonDaoOptions): Promise<BM[]>;
@@ -79,10 +78,6 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * "Returns", just to have a type of "Saved"
      */
     assignIdCreatedUpdated<T extends BaseDBEntity>(obj: Partial<T>, opt?: CommonDaoOptions): T;
-    /**
-     * Mutates with id, created, updated
-     */
-    save(bm: Unsaved<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<BM>;
     /**
      * 1. Applies the patch
      * 2. If object is the same after patching - skips saving it
@@ -117,7 +112,11 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * Like patch, but runs all operations within a Transaction.
      */
     patchInTransaction(bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
-    saveAsDBM(dbm: Unsaved<DBM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<DBM>;
+    /**
+     * Mutates with id, created, updated
+     */
+    save(bm: Unsaved<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<BM>;
+    saveAsDBM(dbm: Unsaved<DBM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<DBM>;
     saveBatch(bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM[]>;
     saveBatchAsDBM(dbms: Unsaved<DBM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<DBM[]>;
     /**
@@ -130,7 +129,6 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     /**
      * @returns number of deleted items
      */
-    deleteById(id: undefined | null, opt?: CommonDaoOptions): Promise<0>;
     deleteById(id?: string | null, opt?: CommonDaoOptions): Promise<number>;
     deleteByIds(ids: string[], opt?: CommonDaoOptions): Promise<number>;
     /**
@@ -156,10 +154,9 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     anyToDBM(dbm?: any, opt?: CommonDaoOptions): DBM;
     anyToDBMs(entities: DBM[], opt?: CommonDaoOptions): DBM[];
     /**
-     * Returns *converted value*.
-     * Validates (unless `skipValidation=true` passed).
-     *
+     * Returns *converted value* (NOT the same reference).
      * Does NOT mutate the object.
+     * Validates (unless `skipValidation=true` passed).
      */
     validateAndConvert<T>(obj: Partial<T>, schema: ObjectSchema<T> | AjvSchema<T> | ZodSchema<T> | undefined, opt?: CommonDaoOptions): any;
     getTableSchema(): Promise<JsonSchemaRootObject<DBM>>;
@@ -194,8 +191,16 @@ export declare class CommonDaoTransaction {
     rollback(): Promise<void>;
     getById<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, id?: string | null, opt?: CommonDaoOptions): Promise<BM | null>;
     getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, ids: string[], opt?: CommonDaoOptions): Promise<BM[]>;
-    save<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, bm: Unsaved<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
+    save<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, bm: Unsaved<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<BM>;
     saveBatch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM[]>;
+    /**
+     * DaoTransaction.patch does not load from DB.
+     * It assumes the bm was previously loaded in the same Transaction, hence could not be
+     * concurrently modified. Hence it's safe to not sync with DB.
+     *
+     * So, this method is a rather simple convenience "Object.assign and then save".
+     */
+    patch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<BM>;
     deleteById(dao: CommonDao<any>, id?: string | null, opt?: CommonDaoOptions): Promise<number>;
     deleteByIds(dao: CommonDao<any>, ids: string[], opt?: CommonDaoOptions): Promise<number>;
 }

package/dist/commondao/common.dao.js

@@ -71,13 +71,6 @@ class CommonDao {
             return bm;
         return this.create({ ...part, id }, opt);
     }
-    async getByIdAsDBMOrEmpty(id, part = {}, opt) {
-        const dbm = await this.getByIdAsDBM(id, opt);
-        if (dbm)
-            return dbm;
-        const bm = this.create({ ...part, id }, opt);
-        return await this.bmToDBM(bm, opt);
-    }
     async getByIdAsDBM(id, opt = {}) {
         if (!id)
             return null;
@@ -451,45 +444,6 @@ class CommonDao {
         return obj;
     }
     // SAVE
-    /**
-     * Mutates with id, created, updated
-     */
-    async save(bm, opt = {}) {
-        this.requireWriteAccess();
-        if (opt.skipIfEquals && (0, js_lib_1._deepJsonEquals)(bm, opt.skipIfEquals)) {
-            // Skipping the save operation
-            return bm;
-        }
-        const idWasGenerated = !bm.id && this.cfg.generateId;
-        this.assignIdCreatedUpdated(bm, opt); // mutates
-        (0, js_lib_1._typeCast)(bm);
-        let dbm = await this.bmToDBM(bm, opt); // validates BM
-        if (this.cfg.hooks.beforeSave) {
-            dbm = (await this.cfg.hooks.beforeSave(dbm));
-            if (dbm === null)
-                return bm;
-        }
-        const table = opt.table || this.cfg.table;
-        if (opt.ensureUniqueId && idWasGenerated)
-            await this.ensureUniqueId(table, dbm);
-        if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
-            opt = { ...opt, saveMethod: 'insert' };
-        }
-        const op = `save(${dbm.id})`;
-        const started = this.logSaveStarted(op, bm, table);
-        const { excludeFromIndexes } = this.cfg;
-        const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds;
-        await (opt.tx || this.cfg.db).saveBatch(table, [dbm], {
-            excludeFromIndexes,
-            assignGeneratedIds,
-            ...opt,
-        });
-        if (assignGeneratedIds) {
-            bm.id = dbm.id;
-        }
-        this.logSaveResult(started, op, table);
-        return bm;
-    }
     /**
      * 1. Applies the patch
      * 2. If object is the same after patching - skips saving it
@@ -585,6 +539,51 @@ class CommonDao {
             return await this.patch(bm, patch, { ...opt, tx: daoTx.tx });
         });
     }
+    /**
+     * Mutates with id, created, updated
+     */
+    async save(bm, opt = {}) {
+        this.requireWriteAccess();
+        if (opt.skipIfEquals) {
+            // We compare with convertedBM, to account for cases when some extra property is assigned to bm,
+            // which should be removed post-validation, but it breaks the "equality check"
+            // Post-validation the equality check should work as intended
+            const convertedBM = this.validateAndConvert(bm, this.cfg.bmSchema, opt);
+            if ((0, js_lib_1._deepJsonEquals)(convertedBM, opt.skipIfEquals)) {
+                // Skipping the save operation
+                return bm;
+            }
+        }
+        const idWasGenerated = !bm.id && this.cfg.generateId;
+        this.assignIdCreatedUpdated(bm, opt); // mutates
+        (0, js_lib_1._typeCast)(bm);
+        let dbm = await this.bmToDBM(bm, opt); // validates BM
+        if (this.cfg.hooks.beforeSave) {
+            dbm = (await this.cfg.hooks.beforeSave(dbm));
+            if (dbm === null)
+                return bm;
+        }
+        const table = opt.table || this.cfg.table;
+        if (opt.ensureUniqueId && idWasGenerated)
+            await this.ensureUniqueId(table, dbm);
+        if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
+            opt = { ...opt, saveMethod: 'insert' };
+        }
+        const op = `save(${dbm.id})`;
+        const started = this.logSaveStarted(op, bm, table);
+        const { excludeFromIndexes } = this.cfg;
+        const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds;
+        await (opt.tx || this.cfg.db).saveBatch(table, [dbm], {
+            excludeFromIndexes,
+            assignGeneratedIds,
+            ...opt,
+        });
+        if (assignGeneratedIds) {
+            bm.id = dbm.id;
+        }
+        this.logSaveResult(started, op, table);
+        return bm;
+    }
     async saveAsDBM(dbm, opt = {}) {
         this.requireWriteAccess();
         const table = opt.table || this.cfg.table;
@@ -736,17 +735,14 @@ class CommonDao {
             (0, nodejs_lib_1.writableVoid)(),
         ];
     }
+    // DELETE
+    /**
+     * @returns number of deleted items
+     */
     async deleteById(id, opt = {}) {
         if (!id)
             return 0;
-        this.requireWriteAccess();
-        this.requireObjectMutability(opt);
-        const op = `deleteById(${id})`;
-        const table = opt.table || this.cfg.table;
-        const started = this.logStarted(op, table);
-        const count = await this.cfg.db.deleteByIds(table, [id], opt);
-        this.logSaveResult(started, op, table);
-        return count;
+        return await this.deleteByIds([id], opt);
     }
     async deleteByIds(ids, opt = {}) {
         if (!ids.length)
@@ -830,13 +826,7 @@ class CommonDao {
             dbm = this.cfg.hooks.anonymize(dbm);
         }
         // DBM > BM
-        let bm;
-        if (this.cfg.hooks.beforeDBMToBM) {
-            bm = await this.cfg.hooks.beforeDBMToBM(dbm);
-        }
-        else {
-            bm = dbm;
-        }
+        const bm = ((await this.cfg.hooks.beforeDBMToBM?.(dbm)) || dbm);
         // Validate/convert BM
         return this.validateAndConvert(bm, this.cfg.bmSchema, opt);
     }
@@ -846,21 +836,10 @@ class CommonDao {
     async bmToDBM(bm, opt) {
         if (bm === undefined)
             return;
-        // should not do it on load, but only on save!
-        // this.assignIdCreatedUpdated(bm, opt)
         // bm gets assigned to the new reference
         bm = this.validateAndConvert(bm, this.cfg.bmSchema, opt);
         // BM > DBM
-        let dbm;
-        if (this.cfg.hooks.beforeBMToDBM) {
-            dbm = { ...(await this.cfg.hooks.beforeBMToDBM(bm)) };
-        }
-        else {
-            dbm = bm;
-        }
-        // Validate/convert DBM
-        // return this.validateAndConvert(dbm, this.cfg.dbmSchema, DBModelType.DBM, opt)
-        return dbm;
+        return ((await this.cfg.hooks.beforeBMToDBM?.(bm)) || bm);
     }
     async bmsToDBM(bms, opt = {}) {
         // try/catch?
@@ -885,10 +864,9 @@ class CommonDao {
         return entities.map(entity => this.anyToDBM(entity, opt));
     }
     /**
-     * Returns *converted value*.
-     * Validates (unless `skipValidation=true` passed).
-     *
+     * Returns *converted value* (NOT the same reference).
      * Does NOT mutate the object.
+     * Validates (unless `skipValidation=true` passed).
      */
     validateAndConvert(obj, schema, opt = {}) {
         // Kirill 2021-10-18: I realized that there's little reason to keep removing null values
@@ -1060,11 +1038,23 @@ class CommonDaoTransaction {
     //   }
     // }
     async save(dao, bm, opt) {
-        return (await this.saveBatch(dao, [bm], opt))[0];
+        return await dao.save(bm, { ...opt, tx: this.tx });
     }
     async saveBatch(dao, bms, opt) {
         return await dao.saveBatch(bms, { ...opt, tx: this.tx });
     }
+    /**
+     * DaoTransaction.patch does not load from DB.
+     * It assumes the bm was previously loaded in the same Transaction, hence could not be
+     * concurrently modified. Hence it's safe to not sync with DB.
+     *
+     * So, this method is a rather simple convenience "Object.assign and then save".
+     */
+    async patch(dao, bm, patch, opt) {
+        const skipIfEquals = (0, js_lib_1._deepCopy)(bm);
+        Object.assign(bm, patch);
+        return await dao.save(bm, { ...opt, skipIfEquals, tx: this.tx });
+    }
     async deleteById(dao, id, opt) {
         if (!id)
             return 0;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/db-lib",
   "scripts": {
-    "prepare": "husky install"
+    "prepare": "husky"
   },
   "dependencies": {
     "@naturalcycles/js-lib": "^14.116.0",
@@ -40,7 +40,7 @@
   "engines": {
     "node": ">=18.12"
   },
-  "version": "9.6.0",
+  "version": "9.7.1",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/commondao/common.dao.ts

@@ -1,6 +1,7 @@
 import { Transform } from 'node:stream'
 import {
   _assert,
+  _deepCopy,
   _deepJsonEquals,
   _filterUndefinedValues,
   _isTruthy,
@@ -131,18 +132,6 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     return this.create({ ...part, id }, opt)
   }
 
-  async getByIdAsDBMOrEmpty(
-    id: string,
-    part: Partial<BM> = {},
-    opt?: CommonDaoOptions,
-  ): Promise<DBM> {
-    const dbm = await this.getByIdAsDBM(id, opt)
-    if (dbm) return dbm
-
-    const bm = this.create({ ...part, id }, opt)
-    return await this.bmToDBM(bm, opt)
-  }
-
   async getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
   async getByIdAsDBM(id?: string | null, opt?: CommonDaoOptions): Promise<DBM | null>
   async getByIdAsDBM(id?: string | null, opt: CommonDaoOptions = {}): Promise<DBM | null> {
@@ -615,51 +604,6 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
   }
 
   // SAVE
-  /**
-   * Mutates with id, created, updated
-   */
-  async save(bm: Unsaved<BM>, opt: CommonDaoSaveOptions<BM, DBM> = {}): Promise<BM> {
-    this.requireWriteAccess()
-
-    if (opt.skipIfEquals && _deepJsonEquals(bm, opt.skipIfEquals)) {
-      // Skipping the save operation
-      return bm as BM
-    }
-
-    const idWasGenerated = !bm.id && this.cfg.generateId
-    this.assignIdCreatedUpdated(bm, opt) // mutates
-    _typeCast<BM>(bm)
-    let dbm = await this.bmToDBM(bm, opt) // validates BM
-
-    if (this.cfg.hooks!.beforeSave) {
-      dbm = (await this.cfg.hooks!.beforeSave(dbm))!
-      if (dbm === null) return bm
-    }
-
-    const table = opt.table || this.cfg.table
-    if (opt.ensureUniqueId && idWasGenerated) await this.ensureUniqueId(table, dbm)
-    if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
-      opt = { ...opt, saveMethod: 'insert' }
-    }
-    const op = `save(${dbm.id})`
-    const started = this.logSaveStarted(op, bm, table)
-    const { excludeFromIndexes } = this.cfg
-    const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds
-
-    await (opt.tx || this.cfg.db).saveBatch(table, [dbm], {
-      excludeFromIndexes,
-      assignGeneratedIds,
-      ...opt,
-    })
-
-    if (assignGeneratedIds) {
-      bm.id = dbm.id
-    }
-
-    this.logSaveResult(started, op, table)
-    return bm
-  }
-
   /**
    * 1. Applies the patch
    * 2. If object is the same after patching - skips saving it
@@ -782,7 +726,58 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     })
   }
 
-  async saveAsDBM(dbm: Unsaved<DBM>, opt: CommonDaoSaveBatchOptions<DBM> = {}): Promise<DBM> {
+  /**
+   * Mutates with id, created, updated
+   */
+  async save(bm: Unsaved<BM>, opt: CommonDaoSaveOptions<BM, DBM> = {}): Promise<BM> {
+    this.requireWriteAccess()
+
+    if (opt.skipIfEquals) {
+      // We compare with convertedBM, to account for cases when some extra property is assigned to bm,
+      // which should be removed post-validation, but it breaks the "equality check"
+      // Post-validation the equality check should work as intended
+      const convertedBM = this.validateAndConvert(bm as Partial<BM>, this.cfg.bmSchema, opt)
+      if (_deepJsonEquals(convertedBM, opt.skipIfEquals)) {
+        // Skipping the save operation
+        return bm as BM
+      }
+    }
+
+    const idWasGenerated = !bm.id && this.cfg.generateId
+    this.assignIdCreatedUpdated(bm, opt) // mutates
+    _typeCast<BM>(bm)
+    let dbm = await this.bmToDBM(bm, opt) // validates BM
+
+    if (this.cfg.hooks!.beforeSave) {
+      dbm = (await this.cfg.hooks!.beforeSave(dbm))!
+      if (dbm === null) return bm
+    }
+
+    const table = opt.table || this.cfg.table
+    if (opt.ensureUniqueId && idWasGenerated) await this.ensureUniqueId(table, dbm)
+    if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
+      opt = { ...opt, saveMethod: 'insert' }
+    }
+    const op = `save(${dbm.id})`
+    const started = this.logSaveStarted(op, bm, table)
+    const { excludeFromIndexes } = this.cfg
+    const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds
+
+    await (opt.tx || this.cfg.db).saveBatch(table, [dbm], {
+      excludeFromIndexes,
+      assignGeneratedIds,
+      ...opt,
+    })
+
+    if (assignGeneratedIds) {
+      bm.id = dbm.id
+    }
+
+    this.logSaveResult(started, op, table)
+    return bm
+  }
+
+  async saveAsDBM(dbm: Unsaved<DBM>, opt: CommonDaoSaveOptions<BM, DBM> = {}): Promise<DBM> {
     this.requireWriteAccess()
     const table = opt.table || this.cfg.table
 
@@ -979,18 +974,9 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
   /**
    * @returns number of deleted items
    */
-  async deleteById(id: undefined | null, opt?: CommonDaoOptions): Promise<0>
-  async deleteById(id?: string | null, opt?: CommonDaoOptions): Promise<number>
   async deleteById(id?: string | null, opt: CommonDaoOptions = {}): Promise<number> {
     if (!id) return 0
-    this.requireWriteAccess()
-    this.requireObjectMutability(opt)
-    const op = `deleteById(${id})`
-    const table = opt.table || this.cfg.table
-    const started = this.logStarted(op, table)
-    const count = await this.cfg.db.deleteByIds(table, [id], opt)
-    this.logSaveResult(started, op, table)
-    return count
+    return await this.deleteByIds([id], opt)
   }
 
   async deleteByIds(ids: string[], opt: CommonDaoOptions = {}): Promise<number> {
@@ -1103,15 +1089,9 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     }
 
     // DBM > BM
-    let bm: Partial<BM>
-    if (this.cfg.hooks!.beforeDBMToBM) {
-      bm = await this.cfg.hooks!.beforeDBMToBM(dbm)
-    } else {
-      bm = dbm as any
-    }
+    const bm = ((await this.cfg.hooks!.beforeDBMToBM?.(dbm)) || dbm) as Partial<BM>
 
     // Validate/convert BM
-
     return this.validateAndConvert(bm, this.cfg.bmSchema, opt)
   }
 
@@ -1128,23 +1108,11 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
   async bmToDBM(bm?: BM, opt?: CommonDaoOptions): Promise<DBM | undefined> {
     if (bm === undefined) return
 
-    // should not do it on load, but only on save!
-    // this.assignIdCreatedUpdated(bm, opt)
-
     // bm gets assigned to the new reference
     bm = this.validateAndConvert(bm, this.cfg.bmSchema, opt)
 
     // BM > DBM
-    let dbm: DBM
-    if (this.cfg.hooks!.beforeBMToDBM) {
-      dbm = { ...((await this.cfg.hooks!.beforeBMToDBM(bm!)) as DBM) }
-    } else {
-      dbm = bm as any
-    }
-
-    // Validate/convert DBM
-    // return this.validateAndConvert(dbm, this.cfg.dbmSchema, DBModelType.DBM, opt)
-    return dbm
+    return ((await this.cfg.hooks!.beforeBMToDBM?.(bm!)) || bm) as DBM
   }
 
   async bmsToDBM(bms: BM[], opt: CommonDaoOptions = {}): Promise<DBM[]> {
@@ -1178,10 +1146,9 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
   }
 
   /**
-   * Returns *converted value*.
-   * Validates (unless `skipValidation=true` passed).
-   *
+   * Returns *converted value* (NOT the same reference).
    * Does NOT mutate the object.
+   * Validates (unless `skipValidation=true` passed).
    */
   validateAndConvert<T>(
     obj: Partial<T>,
@@ -1395,9 +1362,9 @@ export class CommonDaoTransaction {
   async save<BM extends BaseDBEntity, DBM extends BaseDBEntity>(
     dao: CommonDao<BM, DBM>,
     bm: Unsaved<BM>,
-    opt?: CommonDaoSaveBatchOptions<DBM>,
+    opt?: CommonDaoSaveOptions<BM, DBM>,
   ): Promise<BM> {
-    return (await this.saveBatch(dao, [bm], opt))[0]!
+    return await dao.save(bm, { ...opt, tx: this.tx })
   }
 
   async saveBatch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(
@@ -1408,6 +1375,24 @@ export class CommonDaoTransaction {
     return await dao.saveBatch(bms, { ...opt, tx: this.tx })
   }
 
+  /**
+   * DaoTransaction.patch does not load from DB.
+   * It assumes the bm was previously loaded in the same Transaction, hence could not be
+   * concurrently modified. Hence it's safe to not sync with DB.
+   *
+   * So, this method is a rather simple convenience "Object.assign and then save".
+   */
+  async patch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(
+    dao: CommonDao<BM, DBM>,
+    bm: BM,
+    patch: Partial<BM>,
+    opt?: CommonDaoSaveOptions<BM, DBM>,
+  ): Promise<BM> {
+    const skipIfEquals = _deepCopy(bm)
+    Object.assign(bm, patch)
+    return await dao.save(bm, { ...opt, skipIfEquals, tx: this.tx })
+  }
+
   async deleteById(
     dao: CommonDao<any>,
     id?: string | null,