law-common 10.19.1-beta.6 → 10.19.1-beta.8

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

@@ -245,7 +245,7 @@ BillingEntityModel.relationConfigs = [
     },
     {
         name: entity_utils_interface_1.EntityEnum.BILLING_TRANSACTION,
-        relation: relation_type_enum_1.RelationType.ONE,
+        relation: relation_type_enum_1.RelationType.MANY,
         key: "billingTransactions",
         mapKeyConfig: {
             relationKey: "billingId",

package/dist/src/utils/helper.fn.util.d.ts

@@ -1,4 +1,4 @@
-import { EntityEnum, EnumEntityType, IBaseEntityServiceResponse, IEntityFilterData } from "../entities";
+import { EntityEnum, EnumEntityType, IBaseEntityServiceResponse, IEntityFilterData, IEntityServiceResponse } from "../entities";
 import { Modify } from "../misc";
 export declare function groupByFunction<T, K>(list: T[], keyGetter: (input: T) => K): Map<K, T[]>;
 export declare function groupByOneToOneFunction<T, K>(list: T[], keyGetter: (input: T) => K): Map<K, T>;
@@ -176,6 +176,42 @@ export declare function transformDate<T extends {
 export declare function capitalizeFirstWord(str: string): string;
 export declare function getEntitiesFromSearchV2Response<E extends EntityEnum, // Enum key like EntityEnum.USER, EntityEnum.PROJECT, etc.
 T extends EnumEntityType<E>>(searchResponseV2: IBaseEntityServiceResponse<EnumEntityType<EntityEnum>>, entityEnumKey: E, EntityClass: new () => T): T[];
+/**
+ * Recursively searches for entities of a specific type within a nested `relatedEntities` structure.
+ *
+ * This function traverses the `relatedEntities` tree, looking for a target entity key.
+ * When found, it collects all `baseEntities` for that key and instantiates them
+ * as instances of the provided `EntityClass`. The function continues to traverse
+ * all nested `relatedEntities` recursively, accumulating all matches.
+ *
+ * @template E - The enum type representing the target entity key (`EntityEnum`).
+ * @template T - The corresponding entity type for the target key (`EnumEntityType<E>`).
+ *
+ * @param relatedEntities - The nested `relatedEntities` structure, typically from a
+ *   `IBaseEntityServiceResponse`. Can be undefined, in which case an empty array is returned.
+ * @param targetKey - The entity key (`EntityEnum`) to search for in the nested structure.
+ * @param EntityClass - A constructor function for the entity type `T`. Used to
+ *   instantiate new objects from the raw base entity data.
+ *
+ * @returns An array of entities of type `T` found at any level of the nested structure.
+ *   If no entities are found, an empty array is returned.
+ *
+ * @example
+ * ```ts
+ * const billingEntities = findEntitiesAtAnyLevel(
+ *   projectUserMappingsOfCurrentUser.relatedEntities,
+ *   EntityEnum.BILLING,
+ *   BillingEntity
+ * );
+ *
+ * console.log(billingEntities); // [BillingEntity {...}, BillingEntity {...}]
+ * ```
+ *
+ * @note
+ * - This function preserves the type of entities by mapping the raw objects to the provided `EntityClass`.
+ * - It can handle deeply nested `relatedEntities` structures.
+ */
+export declare function findEntitiesFromSearchV2RelatedEntities<E extends EntityEnum, T extends EnumEntityType<E>>(relatedEntities: IEntityServiceResponse | undefined, targetKey: EntityEnum, EntityClass: new () => T): T[];
 /**
  * Checks if two decimal numbers are approximately equal within a given tolerance.
  *

package/dist/src/utils/helper.fn.util.js

@@ -33,6 +33,7 @@ exports.createKeyLabelMap = createKeyLabelMap;
 exports.transformDate = transformDate;
 exports.capitalizeFirstWord = capitalizeFirstWord;
 exports.getEntitiesFromSearchV2Response = getEntitiesFromSearchV2Response;
+exports.findEntitiesFromSearchV2RelatedEntities = findEntitiesFromSearchV2RelatedEntities;
 exports.areDecimalNumbersEqual = areDecimalNumbersEqual;
 exports.formatIndianNumber = formatIndianNumber;
 exports.findDuplicateIds = findDuplicateIds;
@@ -399,6 +400,58 @@ function getEntitiesFromSearchV2Response(searchResponseV2, entityEnumKey, Entity
     }
     return (((_a = searchResponseV2.relatedEntities[entityEnumKey]) === null || _a === void 0 ? void 0 : _a.baseEntities) || []).map((entity) => Object.assign(new EntityClass(), entity));
 }
+/**
+ * Recursively searches for entities of a specific type within a nested `relatedEntities` structure.
+ *
+ * This function traverses the `relatedEntities` tree, looking for a target entity key.
+ * When found, it collects all `baseEntities` for that key and instantiates them
+ * as instances of the provided `EntityClass`. The function continues to traverse
+ * all nested `relatedEntities` recursively, accumulating all matches.
+ *
+ * @template E - The enum type representing the target entity key (`EntityEnum`).
+ * @template T - The corresponding entity type for the target key (`EnumEntityType<E>`).
+ *
+ * @param relatedEntities - The nested `relatedEntities` structure, typically from a
+ *   `IBaseEntityServiceResponse`. Can be undefined, in which case an empty array is returned.
+ * @param targetKey - The entity key (`EntityEnum`) to search for in the nested structure.
+ * @param EntityClass - A constructor function for the entity type `T`. Used to
+ *   instantiate new objects from the raw base entity data.
+ *
+ * @returns An array of entities of type `T` found at any level of the nested structure.
+ *   If no entities are found, an empty array is returned.
+ *
+ * @example
+ * ```ts
+ * const billingEntities = findEntitiesAtAnyLevel(
+ *   projectUserMappingsOfCurrentUser.relatedEntities,
+ *   EntityEnum.BILLING,
+ *   BillingEntity
+ * );
+ *
+ * console.log(billingEntities); // [BillingEntity {...}, BillingEntity {...}]
+ * ```
+ *
+ * @note
+ * - This function preserves the type of entities by mapping the raw objects to the provided `EntityClass`.
+ * - It can handle deeply nested `relatedEntities` structures.
+ */
+function findEntitiesFromSearchV2RelatedEntities(relatedEntities, targetKey, EntityClass) {
+    if (!relatedEntities)
+        return [];
+    let result = [];
+    for (const key of Object.keys(relatedEntities)) {
+        const value = relatedEntities[key];
+        // If this key is the target and has baseEntities
+        if (key === targetKey && (value === null || value === void 0 ? void 0 : value.baseEntities)) {
+            result.push(...value.baseEntities.map((entity) => Object.assign(new EntityClass(), entity)));
+        }
+        // If value has relatedEntities, recurse
+        if (value === null || value === void 0 ? void 0 : value.relatedEntities) {
+            result.push(...findEntitiesFromSearchV2RelatedEntities(value.relatedEntities, targetKey, EntityClass));
+        }
+    }
+    return result;
+}
 /**
  * Checks if two decimal numbers are approximately equal within a given tolerance.
  *

package/package.json

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