nicot 1.2.10 → 1.2.12

package/dist/index.mjs

@@ -1397,7 +1397,6 @@ async function getPaginatedResult(qb, entityClass, entityAliasName, take, cursor
 
 // src/crud-base.ts
 import PQueue from "p-queue";
-import { observeDiff } from "nfkit";
 var Relation = (name, options = {}) => {
   return { name, inner: false, ...options };
 };
@@ -2026,52 +2025,120 @@ var CrudBase = class {
     if (!await this.repo.exists({ where })) {
       throw404();
     }
+    const isAtomicObject = (v) => {
+      if (!v || typeof v !== "object") return true;
+      if (v instanceof Date) return true;
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(v)) return true;
+      if (ArrayBuffer.isView(v) || v instanceof ArrayBuffer) return true;
+      return false;
+    };
+    const cloneForSnapshot = (v) => {
+      if (v == null) return v;
+      if (typeof v !== "object") return v;
+      if (v instanceof Date) return new Date(v.getTime());
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(v))
+        return Buffer.from(v);
+      if (ArrayBuffer.isView(v)) return v.slice?.() ?? v;
+      if (v instanceof ArrayBuffer) return v.slice(0);
+      const sc = globalThis.structuredClone;
+      if (typeof sc === "function") {
+        try {
+          return sc(v);
+        } catch {
+        }
+      }
+      if (Array.isArray(v)) return v.map(cloneForSnapshot);
+      const out = {};
+      for (const k of Object.keys(v))
+        out[k] = cloneForSnapshot(v[k]);
+      return out;
+    };
+    const deepEqual = (a, b) => {
+      if (a === b) return true;
+      if (a == null || b == null) return a === b;
+      if (a instanceof Date && b instanceof Date)
+        return a.getTime() === b.getTime();
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(a) && Buffer.isBuffer(b)) {
+        return a.equals(b);
+      }
+      if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+        if (a.byteLength !== b.byteLength) return false;
+        const ua = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
+        const ub = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
+        for (let i = 0; i < ua.length; i++) if (ua[i] !== ub[i]) return false;
+        return true;
+      }
+      if (a instanceof ArrayBuffer && b instanceof ArrayBuffer) {
+        if (a.byteLength !== b.byteLength) return false;
+        const ua = new Uint8Array(a);
+        const ub = new Uint8Array(b);
+        for (let i = 0; i < ua.length; i++) if (ua[i] !== ub[i]) return false;
+        return true;
+      }
+      if (typeof a === "object" && typeof b === "object") {
+        if (Array.isArray(a) || Array.isArray(b)) {
+          if (!Array.isArray(a) || !Array.isArray(b)) return false;
+          if (a.length !== b.length) return false;
+          for (let i = 0; i < a.length; i++)
+            if (!deepEqual(a[i], b[i])) return false;
+          return true;
+        }
+        const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+        for (const k of keys) {
+          if (!deepEqual(a[k], b[k])) return false;
+        }
+        return true;
+      }
+      return false;
+    };
     const op = async (repo) => {
       const ent = await repo.findOne({
         lock: { mode: "pessimistic_write", tables: [repo.metadata.tableName] },
         ...options.find || {},
         where
       });
-      if (!ent) {
-        throw404();
+      if (!ent) throw404();
+      const columns = repo.metadata.columns.map(
+        (c) => c.propertyName
+      );
+      const snapshot = {};
+      const snapshotHasKey = {};
+      for (const key of columns) {
+        snapshotHasKey[key] = Object.prototype.hasOwnProperty.call(ent, key);
+        snapshot[key] = cloneForSnapshot(ent[key]);
       }
-      const initial = { ...ent };
-      let changes = {};
-      const entProxy = observeDiff(ent, (change) => {
-        if (change.type === "delete") {
-          if (initial[change.key] === null) {
-            delete changes[change.key];
-          } else {
-            changes[change.key] = null;
+      const flush = async () => {
+        const patch = {};
+        for (const key of columns) {
+          const hasNow = Object.prototype.hasOwnProperty.call(ent, key);
+          if (!hasNow) {
+            if (snapshotHasKey[key]) {
+              patch[key] = null;
+              snapshotHasKey[key] = true;
+              snapshot[key] = null;
+            }
+            continue;
           }
-        } else {
-          if (change.newValue !== initial[change.key]) {
-            changes[change.key] = change.newValue;
-          } else {
-            delete changes[change.key];
+          const current = ent[key];
+          const before = snapshot[key];
+          if (!deepEqual(before, current)) {
+            patch[key] = current;
+            snapshotHasKey[key] = true;
+            snapshot[key] = cloneForSnapshot(current);
           }
         }
-      });
-      const flush = async () => {
-        if (Object.keys(changes).length) {
-          const currentChanges = { ...changes };
-          Object.assign(initial, changes);
-          changes = {};
-          await repo.update({ id }, currentChanges);
+        if (Object.keys(patch).length) {
+          await repo.update({ id }, patch);
         }
       };
-      const result = await cb(entProxy, { repo, flush });
+      const result = await cb(ent, { repo, flush });
       await flush();
       return result;
     };
     const res = await (options.repo ? op(options.repo) : this.repo.manager.transaction(
       (tdb) => op(tdb.getRepository(this.entityClass))
     ));
-    if (res == null) {
-      return new BlankReturnMessageDto2(200, "success");
-    } else {
-      return new GenericReturnMessageDto(200, "success", res);
-    }
+    return res == null ? new BlankReturnMessageDto2(200, "success") : new GenericReturnMessageDto(200, "success", res);
   }
   async _loadFullTextIndex() {
     const fields = reflector.getArray(