law-common 10.28.2-beta.3 → 10.28.2-beta.5

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

@@ -4,7 +4,7 @@ export declare enum RelationType {
     MANY = "many"
 }
 export declare abstract class BaseEntityModel<T extends EntityEnum | VirtualEntityEnum> {
-    protected entityName: T;
+    readonly entityName: T;
     constructor(entityName: T);
     abstract getRelationConfigs(): any[];
     populateRelationsByIndex(entityIndexMap: EntityIndexMap): void;

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

@@ -1,4 +1,5 @@
 import { EntityEnum, EntityIndexMap, EntityMap, EnumEntityType, EnumToModel, IApiEntity, IBaseEntityApiResponse, VirtualEntityEnum } from "../interface/entity.utils.interface";
+import { BaseEntityModel } from "./base.entity.model";
 export declare function mapToIndex(entityMap: EntityMap): EntityIndexMap;
 export declare function getEntityIndexMap<T extends EntityEnum>(data: IBaseEntityApiResponse<EnumEntityType<T>>, baseEntity: T, reusedConfig?: {
     existingEntityIndexMap: EntityIndexMap;
@@ -17,3 +18,22 @@ export declare function parseEntitiesWithoutModels<T extends EnumEntityType<Enti
     [E in EntityEnum | VirtualEntityEnum]?: IApiEntity<EnumEntityType<E>>[];
 };
 export declare function removeEntityById(entityIndexMap: EntityIndexMap, entity: EntityEnum, id: number): void;
+export declare class EntityModelRelationHelper {
+    entityMap: EntityMap;
+    entityModelMap: EntityMap;
+    entityModelIndexMap: EntityIndexMap;
+    constructor(entityMap: EntityMap);
+    private init;
+    private toEntityModelMap;
+    private fromEntityToEntityModel;
+    private toEntityModelIndexMap;
+    populateRelationsByEntityEnums(entityEnums: EntityEnum[]): EntityModelRelationHelper;
+    populateRelationsByEntityEnum(entityEnum: EntityEnum): void;
+    populateRelationsByEntityModel(entityModel: BaseEntityModel<EntityEnum | VirtualEntityEnum>): void;
+    addEntityModel<T extends EntityEnum | VirtualEntityEnum>(entityModel: BaseEntityModel<T>, config?: {
+        populateRelations?: boolean;
+    }): void;
+    addEntity<T extends EntityEnum | VirtualEntityEnum>(entity: EnumEntityType<T>, entityEnum: T, config?: {
+        populateRelations?: boolean;
+    }): void;
+}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.entityEnumToEntityModel = void 0;
+exports.EntityModelRelationHelper = exports.entityEnumToEntityModel = void 0;
 exports.mapToIndex = mapToIndex;
 exports.getEntityIndexMap = getEntityIndexMap;
 exports.populateRelationsFor = populateRelationsFor;
@@ -131,3 +131,74 @@ function removeEntityById(entityIndexMap, entity, id) {
         delete entityIndexMap[entity][id];
     }
 }
+class EntityModelRelationHelper {
+    constructor(entityMap) {
+        this.entityMap = entityMap;
+        this.entityModelMap = {};
+        this.entityModelIndexMap = {};
+        this.init();
+    }
+    init() {
+        this.toEntityModelMap();
+        this.toEntityModelIndexMap();
+    }
+    toEntityModelMap() {
+        for (const entityName in this.entityMap) {
+            if (!(entityName in exports.entityEnumToEntityModel)) {
+                throw new Error(`Unknown entity: ${entityName}`);
+            }
+            this.entityModelMap[entityName] = this.entityMap[entityName].map((entity) => 
+            // @ts-ignore
+            exports.entityEnumToEntityModel[entityName](entity));
+        }
+        return this;
+    }
+    fromEntityToEntityModel(entity, entityEnum) {
+        if (!(entityEnum in exports.entityEnumToEntityModel)) {
+            throw new Error(`Unknown entity: ${entityEnum}`);
+        }
+        return exports.entityEnumToEntityModel[entityEnum](entity);
+    }
+    toEntityModelIndexMap() {
+        this.entityModelIndexMap = Object.keys(this.entityModelMap).reduce((acc, key) => {
+            // @ts-ignore
+            acc[key] = this.entityModelMap[key].reduce((innerAcc, entity) => {
+                innerAcc[entity.id] = entity;
+                return innerAcc;
+            }, {});
+            return acc;
+        }, {});
+        return this;
+    }
+    populateRelationsByEntityEnums(entityEnums) {
+        entityEnums.forEach((entityEnum) => {
+            this.populateRelationsByEntityEnum(entityEnum);
+        });
+        return this;
+    }
+    populateRelationsByEntityEnum(entityEnum) {
+        for (const key of Object.keys(this.entityModelIndexMap[entityEnum] || {})) {
+            const entityModel = this.entityModelIndexMap[entityEnum][key];
+            entityModel.populateRelationsByIndex(this.entityModelIndexMap);
+        }
+    }
+    populateRelationsByEntityModel(entityModel) {
+        entityModel.populateRelationsByIndex(this.entityModelIndexMap);
+    }
+    addEntityModel(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);
+        }
+    }
+    addEntity(entity, entityEnum, config = { populateRelations: false }) {
+        if (!(entityEnum in exports.entityEnumToEntityModel)) {
+            throw new Error(`Unknown entity: ${entityEnum}`);
+        }
+        this.addEntityModel(this.fromEntityToEntityModel(entity, entityEnum), config);
+    }
+}
+exports.EntityModelRelationHelper = EntityModelRelationHelper;

package/package.json

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