law-common 10.28.2-beta.7 → 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

@@ -0,0 +1,25 @@
+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 arrayComparisonCategory;
+    constructor(incomingArray: T[] | undefined, existingArray: T[] | undefined, keyProperty: keyof T);
+    private get existingMap();
+    private isExistingItem;
+    private isMarkForDeletion;
+    private isIdentifierPresent;
+    compare(): ArrayComparisonCategory<T>;
+    get category(): ArrayComparisonCategory<T> | null;
+    merge(): T[];
+}

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

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayComparisonCategorizer = void 0;
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (typeof a !== typeof b)
+        return false;
+    if (typeof a !== "object")
+        return a === b;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (Array.isArray(a)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((v, i) => deepEqual(v, b[i]));
+    }
+    const keysA = Object.keys(a).sort();
+    const keysB = Object.keys(b).sort();
+    if (keysA.length !== keysB.length)
+        return false;
+    return keysA.every((key) => deepEqual(a[key], b[key]));
+}
+class ArrayComparisonCategorizer {
+    constructor(incomingArray = [], existingArray = [], keyProperty) {
+        this.arrayComparisonCategory = null;
+        this.incomingArray = [...incomingArray];
+        this.existingArray = [...existingArray];
+        this.keyProperty = keyProperty;
+    }
+    get existingMap() {
+        return new Map(this.existingArray.filter((item) => item[this.keyProperty] !== undefined).map((item) => [item[this.keyProperty], item]));
+    }
+    isExistingItem(incomingItem, existingMap) {
+        return existingMap.has(incomingItem[this.keyProperty]);
+    }
+    isMarkForDeletion(incomingItem) {
+        const onlyIdentifierPresent = Object.keys(incomingItem).length === 1;
+        return this.isIdentifierPresent(incomingItem) && onlyIdentifierPresent;
+    }
+    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 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] });
+            }
+            else if (!isIdentifierPresent && !isExistingItem) {
+                added.push(incomingItem);
+            }
+            else if (isExistingItem && isIdentifierPresent) {
+                if (deepEqual(incomingItem, existingItem)) {
+                    unchanged.push(incomingItem);
+                }
+                else {
+                    updated.push(incomingItem);
+                }
+            }
+            else {
+                notFound.push({ [this.keyProperty]: incomingItem[this.keyProperty] });
+            }
+        }
+        const result = {
+            unchanged,
+            added,
+            updated,
+            deleted,
+            notFound
+        };
+        this.arrayComparisonCategory = result;
+        return result;
+    }
+    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;
+            }
+        }
+        // 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.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/dist/src/utils/index.d.ts

@@ -3,3 +3,4 @@ export * from "./helper.fn.util";
 export * from "./models/date-code.model.util";
 export * from "./string.util";
 export * from "./entity.flow.util";
+export * from "./array.util";

package/dist/src/utils/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./helper.fn.util"), exports);
 __exportStar(require("./models/date-code.model.util"), exports);
 __exportStar(require("./string.util"), exports);
 __exportStar(require("./entity.flow.util"), exports);
+__exportStar(require("./array.util"), exports);

package/package.json

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