law-common 10.28.2-beta.8 → 10.28.2-beta.9

package/dist/src/api/index.d.ts

@@ -50,3 +50,5 @@ export * from "./interface/cron-job-manual-trigger.dto.interface";
 export * from "./interface/cron-job.entity.response";
 export * from "./interface/address-book.create.dto.interface";
 export * from "./enums/crud.enum";
+export * from "./interface/api.utils.interface";
+export * from "./interface/address-book.update.dto.interface";

package/dist/src/api/index.js

@@ -70,3 +70,5 @@ __exportStar(require("./interface/cron-job.entity.response"), exports);
 // export * from "./interface/project-user-mapping.entity.api";
 __exportStar(require("./interface/address-book.create.dto.interface"), exports);
 __exportStar(require("./enums/crud.enum"), exports);
+__exportStar(require("./interface/api.utils.interface"), exports);
+__exportStar(require("./interface/address-book.update.dto.interface"), exports);

package/dist/src/api/interface/address-book.update.dto.interface.d.ts

@@ -0,0 +1,5 @@
+import { IAddressBookContactDetail, IAddressBookCreateDto } from "./address-book.create.dto.interface";
+import { DeepPartialButRequired } from "./api.utils.interface";
+export type IAddressBookUpdateDto = DeepPartialButRequired<Omit<IAddressBookCreateDto, 'contactDetails'>, never> & {
+    contactDetails?: DeepPartialButRequired<IAddressBookContactDetail, 'id'>[];
+};

package/dist/src/api/interface/address-book.update.dto.interface.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// const a: IAddressBookUpdateDto = {
+//     organizationName: "Test Name",
+//     contactDetails: [
+//         {
+//             id: 1,
+//             email: "test@example.com",
+//             phone: "123-456-7890"
+//         }
+//     ]
+// };
+// const b: IAddressBookUpdateDto = {
+//     organizationName: "Test Name",
+//     address: {
+//         city: "Sample City"
+//     }
+// };

package/dist/src/api/interface/api.utils.interface.d.ts

@@ -0,0 +1,4 @@
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends object ? DeepPartial<T[P]> : T[P];
+} : T;
+export type DeepPartialButRequired<T, K extends keyof T> = DeepPartial<T> & Required<Pick<T, K>>;

package/dist/src/api/interface/api.utils.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,21 +1,25 @@
-export declare class ArrayChangeTracker<T> {
+export type ArrayComparisonCategory<T> = {
+    unchanged: T[];
+    added: T[];
+    updated: T[];
+    deleted: {
+        [x: string]: T[keyof T];
+    }[];
+    notFound: {
+        [x: string]: T[keyof T];
+    }[];
+};
+export declare class ArrayComparisonCategorizer<T> {
     private incomingArray;
     private existingArray;
     private keyProperty;
-    private unchanged;
-    private added;
-    private updated;
-    private deleted;
-    private notFound;
+    private arrayComparisonCategory;
     constructor(incomingArray: T[] | undefined, existingArray: T[] | undefined, keyProperty: keyof T);
     private get existingMap();
-    unchangedItems(): T[];
-    addedItems(): T[];
-    updatedItems(): T[];
-    deletedItems(): {
-        id: T[keyof T];
-    }[];
-    notFoundItems(): {
-        id: T[keyof T];
-    }[];
+    private isExistingItem;
+    private isMarkForDeletion;
+    private isIdentifierPresent;
+    compare(): ArrayComparisonCategory<T>;
+    get category(): ArrayComparisonCategory<T> | null;
+    merge(): T[];
 }

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayChangeTracker = void 0;
+exports.ArrayComparisonCategorizer = void 0;
 function deepEqual(a, b) {
     if (a === b)
         return true;
@@ -23,53 +23,9 @@ function deepEqual(a, b) {
         return false;
     return keysA.every((key) => deepEqual(a[key], b[key]));
 }
-function categorizeChanges(incoming, existing) {
-    console.log("Categorizing changes between incoming and existing items");
-    console.log("Incoming items:", incoming);
-    console.log("Existing items:", existing);
-    const existingMap = new Map(existing.filter((item) => item.id !== undefined).map((item) => [item.id, item]));
-    const incomingIds = new Set(incoming.filter((item) => item.id !== undefined).map((item) => item.id));
-    const deleted = [];
-    const notFound = [];
-    const unchanged = [];
-    const updated = [];
-    const added = [];
-    for (const item of incoming) {
-        if (item.id === undefined) {
-            added.push(item);
-            continue;
-        }
-        const id = item.id;
-        if (Object.keys(item).length === 1) {
-            deleted.push({ id });
-            continue;
-        }
-        if (!existingMap.has(id)) {
-            added.push(item);
-            continue;
-        }
-        const existingItem = existingMap.get(id);
-        if (deepEqual(item, existingItem)) {
-            unchanged.push(item);
-        }
-        else {
-            updated.push(item);
-        }
-    }
-    for (const [id] of existingMap) {
-        if (!incomingIds.has(id)) {
-            notFound.push({ id });
-        }
-    }
-    return { unchanged, added, updated, deleted, notFound };
-}
-class ArrayChangeTracker {
+class ArrayComparisonCategorizer {
     constructor(incomingArray = [], existingArray = [], keyProperty) {
-        this.unchanged = [];
-        this.added = [];
-        this.updated = [];
-        this.deleted = [];
-        this.notFound = [];
+        this.arrayComparisonCategory = null;
         this.incomingArray = [...incomingArray];
         this.existingArray = [...existingArray];
         this.keyProperty = keyProperty;
@@ -77,72 +33,136 @@ class ArrayChangeTracker {
     get existingMap() {
         return new Map(this.existingArray.filter((item) => item[this.keyProperty] !== undefined).map((item) => [item[this.keyProperty], item]));
     }
-    unchangedItems() {
-        const existingMap = this.existingMap;
-        this.unchanged = [];
-        for (const incomingItem of this.incomingArray) {
-            const isIdentifierPresent = incomingItem[this.keyProperty] !== undefined && incomingItem[this.keyProperty] !== null;
-            const onlyIdentifierPresent = Object.keys(incomingItem).length === 1;
-            const isExistingItem = existingMap.has(incomingItem[this.keyProperty]);
-            if (!isIdentifierPresent || !isExistingItem || onlyIdentifierPresent) {
-                continue;
-            }
-            const id = incomingItem[this.keyProperty];
-            const existingItem = existingMap.get(id);
-            if (deepEqual(incomingItem, existingItem)) {
-                this.unchanged.push(incomingItem);
-            }
-        }
-        return this.unchanged;
+    isExistingItem(incomingItem, existingMap) {
+        return existingMap.has(incomingItem[this.keyProperty]);
     }
-    addedItems() {
-        this.added = [];
-        const existingMap = this.existingMap;
-        for (const incomingItem of this.incomingArray) {
-            if (!existingMap.has(incomingItem[this.keyProperty])) {
-                this.added.push(incomingItem);
-                continue;
-            }
-        }
-        return this.added;
+    isMarkForDeletion(incomingItem) {
+        const onlyIdentifierPresent = Object.keys(incomingItem).length === 1;
+        return this.isIdentifierPresent(incomingItem) && onlyIdentifierPresent;
     }
-    updatedItems() {
-        this.updated = [];
+    isIdentifierPresent(incomingItem) {
+        return incomingItem[this.keyProperty] !== undefined && incomingItem[this.keyProperty] !== null;
+    }
+    compare() {
         const existingMap = this.existingMap;
+        const unchanged = [];
+        const added = [];
+        const updated = [];
+        const deleted = [];
+        const notFound = [];
         for (const incomingItem of this.incomingArray) {
-            const isExistingItem = existingMap.has(incomingItem[this.keyProperty]);
-            if (!isExistingItem) {
-                continue;
+            const isIdentifierPresent = this.isIdentifierPresent(incomingItem);
+            const isMarkForDeletion = isIdentifierPresent && this.isMarkForDeletion(incomingItem);
+            const isExistingItem = isIdentifierPresent && this.isExistingItem(incomingItem, existingMap);
+            const existingItem = isExistingItem ? existingMap.get(incomingItem[this.keyProperty]) : null;
+            if (isMarkForDeletion) {
+                deleted.push({ [this.keyProperty]: incomingItem[this.keyProperty] });
             }
-            const id = incomingItem[this.keyProperty];
-            const existingItem = existingMap.get(id);
-            if (!deepEqual(incomingItem, existingItem)) {
-                this.updated.push(incomingItem);
+            else if (!isIdentifierPresent && !isExistingItem) {
+                added.push(incomingItem);
             }
-        }
-        return this.updated;
-    }
-    deletedItems() {
-        this.deleted = [];
-        for (const incomingItem of this.incomingArray) {
-            const isIdentifierPresent = incomingItem[this.keyProperty] !== undefined && incomingItem[this.keyProperty] !== null;
-            const onlyIdentifierPresent = Object.keys(incomingItem).length === 1;
-            if (isIdentifierPresent && onlyIdentifierPresent) {
-                this.deleted.push({ id: incomingItem[this.keyProperty] });
+            else if (isExistingItem && isIdentifierPresent) {
+                if (deepEqual(incomingItem, existingItem)) {
+                    unchanged.push(incomingItem);
+                }
+                else {
+                    updated.push(incomingItem);
+                }
+            }
+            else {
+                notFound.push({ [this.keyProperty]: incomingItem[this.keyProperty] });
             }
         }
-        return this.deleted;
+        const result = {
+            unchanged,
+            added,
+            updated,
+            deleted,
+            notFound
+        };
+        this.arrayComparisonCategory = result;
+        return result;
     }
-    notFoundItems() {
-        this.notFound = [];
-        const existingMap = this.existingMap;
-        for (const incomingItem of this.existingArray) {
-            const isIdentifierPresent = incomingItem[this.keyProperty] !== undefined && incomingItem[this.keyProperty] !== null;
-            if (isIdentifierPresent && !existingMap.has(incomingItem[this.keyProperty])) {
-                this.notFound.push({ id: incomingItem[this.keyProperty] });
+    get category() {
+        return this.arrayComparisonCategory;
+    }
+    merge() {
+        if (!this.arrayComparisonCategory) {
+            throw new Error("ArrayComparisonCategory is not computed yet. Call compare() first.");
+        }
+        const changes = this.arrayComparisonCategory;
+        let newState = this.existingArray.filter(this.isIdentifierPresent.bind(this));
+        // Remove deleted items
+        const deletedIds = new Set(changes.deleted.map((d) => d[this.keyProperty]));
+        newState = newState.filter((item) => !deletedIds.has(item[this.keyProperty]));
+        // Update items
+        for (let i = 0; i < newState.length; i++) {
+            const item = newState[i];
+            const updatedItem = changes.updated.find((u) => u[this.keyProperty] === item[this.keyProperty]);
+            if (updatedItem) {
+                newState[i] = updatedItem;
             }
         }
-        return this.notFound;
+        // Get Max Id
+        const existingWithId = this.existingArray.filter(this.isIdentifierPresent.bind(this));
+        const originalMaxId = existingWithId.length > 0
+            ? Math.max(...existingWithId.map((item) => item[this.keyProperty]))
+            : 0;
+        // Add new items with new identifier
+        let currentMaxId = originalMaxId;
+        for (const item of changes.added) {
+            const id = ++currentMaxId;
+            newState.push(Object.assign(Object.assign({}, item), { [this.keyProperty]: id }));
+        }
+        return newState;
     }
 }
-exports.ArrayChangeTracker = ArrayChangeTracker;
+exports.ArrayComparisonCategorizer = ArrayComparisonCategorizer;
+// function categorizeChanges<T extends Item>(
+//   incoming: T[],
+//   existing: T[]
+// ): {
+//   unchanged: T[];
+//   added: T[];
+//   updated: T[];
+//   deleted: { id: number }[];
+//   notFound: { id: number }[];
+// } {
+//   console.log("Categorizing changes between incoming and existing items");
+//   console.log("Incoming items:", incoming);
+//   console.log("Existing items:", existing);
+//   const existingMap = new Map<number, T>(existing.filter((item) => item.id !== undefined).map((item) => [item.id!, item]));
+//   const incomingIds = new Set<number>(incoming.filter((item) => item.id !== undefined).map((item) => item.id!));
+//   const deleted: { id: number }[] = [];
+//   const notFound: { id: number }[] = [];
+//   const unchanged: T[] = [];
+//   const updated: T[] = [];
+//   const added: T[] = [];
+//   for (const item of incoming) {
+//     if (item.id === undefined) {
+//       added.push(item);
+//       continue;
+//     }
+//     const id = item.id;
+//     if (Object.keys(item).length === 1) {
+//       deleted.push({ id });
+//       continue;
+//     }
+//     if (!existingMap.has(id)) {
+//       added.push(item);
+//       continue;
+//     }
+//     const existingItem = existingMap.get(id)!;
+//     if (deepEqual(item, existingItem)) {
+//       unchanged.push(item);
+//     } else {
+//       updated.push(item);
+//     }
+//   }
+//   for (const [id] of existingMap) {
+//     if (!incomingIds.has(id)) {
+//       notFound.push({ id });
+//     }
+//   }
+//   return { unchanged, added, updated, deleted, notFound };
+// }

package/package.json

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