law-common 10.28.2-beta.10 → 10.28.2-beta.11

package/dist/src/entities/model/entity.model.interface.d.ts

@@ -36,4 +36,7 @@ export declare class EntityModelRelationHelper {
     addEntity<T extends EntityEnum | VirtualEntityEnum>(entity: EnumEntityType<T>, entityEnum: T, config?: {
         populateRelations?: boolean;
     }): void;
+    updateEntityModel<T extends EntityEnum | VirtualEntityEnum>(entityModel: BaseEntityModel<T>, config?: {
+        populateRelations?: boolean;
+    }): void;
 }

package/dist/src/entities/model/entity.model.interface.js

@@ -200,5 +200,14 @@ class EntityModelRelationHelper {
         }
         this.addEntityModel(this.fromEntityToEntityModel(entity, entityEnum), config);
     }
+    updateEntityModel(entityModel, config = { populateRelations: false }) {
+        const entityEnum = entityModel.entityName;
+        this.entityModelIndexMap[entityEnum] = this.entityModelIndexMap[entityEnum] || {};
+        // @ts-ignore
+        this.entityModelIndexMap[entityEnum][entityModel.id] = entityModel;
+        if (config.populateRelations) {
+            this.populateRelationsByEntityModel(entityModel);
+        }
+    }
 }
 exports.EntityModelRelationHelper = EntityModelRelationHelper;

package/dist/src/utils/object.util.d.ts

@@ -0,0 +1,10 @@
+interface ComparableObject {
+    [key: string]: any;
+}
+declare class ObjectComparator {
+    private incoming;
+    private existing;
+    constructor(incoming: ComparableObject, existing: ComparableObject);
+    compare(): ComparableObject;
+    private deepDiff;
+}

package/dist/src/utils/object.util.js

@@ -0,0 +1,134 @@
+"use strict";
+class ObjectComparator {
+    constructor(incoming, existing) {
+        this.incoming = incoming;
+        this.existing = existing;
+    }
+    compare() {
+        return this.deepDiff(this.incoming, this.existing);
+    }
+    deepDiff(a, b) {
+        // Handle null/undefined cases
+        if (a == null && b == null) {
+            return undefined;
+        }
+        if (a == null || b == null) {
+            return a;
+        }
+        // Handle primitives (loose equality)
+        if (typeof a !== "object") {
+            return a == b ? undefined : a;
+        }
+        // a is object or array
+        if (Array.isArray(a)) {
+            // Handle as array
+            const diffArr = new Array(a.length);
+            let hasDiff = false;
+            for (let i = 0; i < a.length; i++) {
+                const subB = Array.isArray(b) && i < b.length ? b[i] : undefined;
+                const subDiff = this.deepDiff(a[i], subB);
+                if (subDiff !== undefined) {
+                    diffArr[i] = subDiff;
+                    hasDiff = true;
+                }
+            }
+            return hasDiff ? diffArr : undefined;
+        }
+        else {
+            // Handle as object
+            const diff = {};
+            let hasDiff = false;
+            for (const key of Object.keys(a)) {
+                const subDiff = this.deepDiff(a[key], b === null || b === void 0 ? void 0 : b[key]);
+                if (subDiff !== undefined) {
+                    diff[key] = subDiff;
+                    hasDiff = true;
+                }
+            }
+            return hasDiff ? diff : undefined;
+        }
+    }
+}
+// // Comprehensive Usage Examples
+// // Example 1: Simple object with primitive differences
+// console.log("Example 1: Simple object");
+// const incoming1 = { name: "Alice", age: 30, city: "New York" };
+// const existing1 = { name: "Bob", age: 30, city: "Boston" };
+// const comparator1 = new ObjectComparator(incoming1, existing1);
+// console.log(comparator1.compare()); // Output: { name: 'Alice', city: 'New York' }
+// // Example 2: Nested objects
+// console.log("Example 2: Nested objects");
+// const incoming2 = {
+//   user: { id: 1, profile: { email: "alice@example.com", phone: "123-456" } },
+//   settings: { theme: "dark", notifications: true },
+// };
+// const existing2 = {
+//   user: { id: 1, profile: { email: "bob@example.com" } },
+//   settings: { theme: "light" },
+// };
+// const comparator2 = new ObjectComparator(incoming2, existing2);
+// console.log(comparator2.compare());
+// // Output: {
+// //   user: { profile: { email: 'alice@example.com', phone: '123-456' } },
+// //   settings: { theme: 'dark', notifications: true }
+// // }
+// // Example 3: Array of primitives
+// console.log("Example 3: Array of primitives");
+// const incoming3 = { scores: [95, 87, 100] };
+// const existing3 = { scores: [80, 87, 90] };
+// const comparator3 = new ObjectComparator(incoming3, existing3);
+// console.log(comparator3.compare()); // Output: { scores: [95, undefined, 100] }
+// // Example 4: Array of objects
+// console.log("Example 4: Array of objects");
+// const incoming4 = {
+//   items: [
+//     { id: 1, name: "Item A", price: 10 },
+//     { id: 2, name: "Item B", price: 20 },
+//     { id: 3, name: "Item C", price: 30 },
+//   ],
+// };
+// const existing4 = {
+//   items: [
+//     { id: 1, name: "Item A", price: 15 },
+//     { id: 2, name: "Item X", price: 20 },
+//   ],
+// };
+// const comparator4 = new ObjectComparator(incoming4, existing4);
+// console.log(comparator4.compare());
+// // Output: {
+// //   items: [
+// //     { price: 10 },
+// //     { name: 'Item B' },
+// //     { id: 3, name: 'Item C', price: 30 }
+// //   ]
+// // }
+// // Example 5: Mixed structure with missing properties and nulls
+// console.log("Example 5: Mixed with nulls and missing");
+// const incoming5 = {
+//   data: {
+//     value: null,
+//     list: [1, 2, { nested: "hello" }],
+//     extra: "new",
+//   },
+// };
+// const existing5 = {
+//   data: {
+//     value: 42,
+//     list: [1, 3],
+//   },
+// };
+// const comparator5 = new ObjectComparator(incoming5, existing5);
+// console.log(comparator5.compare());
+// // Output: {
+// //   data: {
+// //     value: null,
+// //     list: [undefined, 2, { nested: 'hello' }],
+// //     extra: 'new'
+// //   }
+// // }
+// // Example 6: No differences
+// console.log("Example 6: No differences");
+// const incoming6 = { a: 1, b: { c: [true] } };
+// const existing6 = { a: 1, b: { c: [true] } };
+// const comparator6 = new ObjectComparator(incoming6, existing6);
+// console.log(comparator6.compare()); // Output: {}

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "law-common",
- "version": "10.28.2-beta.10",
+ "version": "10.28.2-beta.11",
  "description": "",
  "main": "dist/index.js",
  "files": [