@koalarx/nest 3.1.28 → 3.1.30

package/core/database/entity.base.d.ts

@@ -1,4 +1,5 @@
 import { Overwrite } from '..';
+import { AutomapContext } from '../utils/automap-cycle-context';
 import { IComparable, IComparableId } from '../utils/interfaces/icomparable';
 export declare enum EntityActionType {
     create = 1,
@@ -15,6 +16,6 @@ export declare abstract class EntityBase<T extends IComparable<T>> implements IC
     _id: IComparableId;
     _action: EntityActionType;
     constructor(props?: EntityProps<T>);
-    automap(props?: EntityProps<T>): void;
+    automap(props?: EntityProps<T>, context?: AutomapContext): void;
     equals(obj: EntityBase<T>): boolean;
 }

package/core/database/entity.base.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityBase = exports.EntityActionType = void 0;
 const utils_1 = require("@koalarx/utils");
 const auto_mapping_list_1 = require("../mapping/auto-mapping-list");
+const automap_cycle_context_1 = require("../utils/automap-cycle-context");
 const list_1 = require("../utils/list");
 var EntityActionType;
 (function (EntityActionType) {
@@ -17,8 +18,15 @@ class EntityBase {
             this.automap(props);
         }
     }
-    automap(props) {
+    automap(props, context = (0, automap_cycle_context_1.createAutomapContext)()) {
         if (props) {
+            if (typeof props === 'object' && props !== null) {
+                const cachedInstance = context.references.get(props);
+                if (cachedInstance && cachedInstance !== this) {
+                    return;
+                }
+                context.references.set(props, this);
+            }
             for (const key of Object.keys(props)) {
                 if (props[key] === undefined) {
                     continue;
@@ -29,10 +37,7 @@ class EntityBase {
                     let value = props[key];
                     if (this[key].entityType) {
                         value = value.map((item) => {
-                            const entity = new this[key].entityType();
-                            entity._action = this._action;
-                            entity.automap(item);
-                            return entity;
+                            return (0, automap_cycle_context_1.mapEntityReference)(item, this[key].entityType, context, this._action);
                         });
                     }
                     this[key].setList(value);
@@ -51,10 +56,7 @@ class EntityBase {
                 }
                 else if (EntityOnPropKey) {
                     if (props[key]) {
-                        const entity = new EntityOnPropKey();
-                        entity._action = this._action;
-                        entity.automap(props[key]);
-                        this[key] = entity;
+                        this[key] = (0, automap_cycle_context_1.mapEntityReference)(props[key], EntityOnPropKey, context, this._action);
                     }
                 }
                 else if (propDefinitions) {

package/core/database/entity.decorator.d.ts

@@ -12,7 +12,7 @@ export declare function Entity<T extends new (...args: any[]) => EntityBase<any>
     new (...args: any[]): {
         _id: import("../utils/interfaces/icomparable").IComparableId;
         _action: import("./entity.base").EntityActionType;
-        automap(props?: import("./entity.base").EntityProps<any> | undefined): void;
+        automap(props?: import("./entity.base").EntityProps<any> | undefined, context?: import("../utils/automap-cycle-context").AutomapContext): void;
         equals(obj: EntityBase<any>): boolean;
     };
 } & T;

package/core/database/repository.base.d.ts

@@ -14,6 +14,7 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>
     private readonly _modelName;
     private readonly _includeFindMany?;
     constructor({ context, modelName }: RepositoryInitProps<TEntity, TContext>);
+    private get entityInstance();
     private getIdPropName;
     private getWhereByIdSchema;
     private getConnectPrismaSchemaForRelation;
@@ -30,6 +31,7 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>
     private orphanRemoval;
     private getIdOnEntity;
     private loadRelationForEntity;
+    private loadEntityFromCache;
     private enrichEntityWithRelations;
     private persistRelations;
     protected context(transactionalClient?: TContext): TContext[TModelKey];

package/core/database/repository.base.js

@@ -6,9 +6,10 @@ const pagination_dto_1 = require("../dtos/pagination.dto");
 const koala_global_vars_1 = require("../koala-global-vars");
 const auto_mapping_list_1 = require("../mapping/auto-mapping-list");
 const generate_prisma_include_schema_1 = require("../utils/generate-prisma-include-schema");
+const hydrate_entity_from_cache_1 = require("../utils/hydrate-entity-from-cache");
 const list_1 = require("../utils/list");
-const entity_base_1 = require("./entity.base");
 const proxy_1 = require("../utils/proxy");
+const entity_base_1 = require("./entity.base");
 class RepositoryBase {
     _context;
     _modelName;
@@ -22,6 +23,9 @@ class RepositoryBase {
             entity: this._modelName,
         });
     }
+    get entityInstance() {
+        return this._modelName.prototype.constructor;
+    }
     getIdPropName(entity) {
         const idConfig = Reflect.getMetadata('entity:id', entity ? entity.constructor.prototype : this._modelName.prototype);
         if (idConfig) {
@@ -310,6 +314,24 @@ class RepositoryBase {
         })
             .then((data) => this.enrichEntityWithRelations(entity, (0, proxy_1.createProxy)(data), cache));
     }
+    loadEntityFromCache(entity, data, cache) {
+        return (0, hydrate_entity_from_cache_1.hydrateEntityFromCache)({
+            entity: entity,
+            data,
+            cache,
+            dependencies: {
+                getAllProps: (sourceEntity) => auto_mapping_list_1.AutoMappingList.getAllProps(sourceEntity),
+                getPropDefinitions: (sourceEntity, propName) => auto_mapping_list_1.AutoMappingList.getPropDefinitions(sourceEntity, propName),
+                getSourceByName: (sourceName) => auto_mapping_list_1.AutoMappingList.getSourceByName(sourceName),
+                getListEntityType: (sourceEntity, propName) => {
+                    const list = new sourceEntity()[propName];
+                    return list.entityType;
+                },
+                getIdOnEntity: (currentEntity, value) => this.getIdOnEntity(currentEntity, value),
+                createEntity: (sourceEntity) => new sourceEntity(),
+            },
+        });
+    }
     async enrichEntityWithRelations(entity, data, cache = new Map()) {
         if (!data) {
             return null;
@@ -321,31 +343,24 @@ class RepositoryBase {
             if (propDef?.type === list_1.List.name) {
                 const list = new entity()[prop.name];
                 const entityInstance = list.entityType;
-                const items = [];
                 for (const item of data[propName] || []) {
-                    const cacheKey = `${entity.name}-${this.getIdOnEntity(new entityInstance(), item)}`;
+                    const cacheKey = `${entityInstance.name}-${this.getIdOnEntity(new entityInstance(), item)}`;
                     if (cache.has(cacheKey)) {
-                        items.push(cache.get(cacheKey));
                         continue;
                     }
                     cache.set(cacheKey, item);
-                    const enrichedItem = await this.loadRelationForEntity(this.getWhereByIdSchema(new entityInstance(), item), entityInstance, cache);
-                    cache.set(cacheKey, enrichedItem);
-                    items.push(enrichedItem);
+                    await this.loadRelationForEntity(this.getWhereByIdSchema(new entityInstance(), item), entityInstance, cache).then((response) => cache.set(cacheKey, response));
                 }
-                data[propName] = items;
                 continue;
             }
             const relationEntity = auto_mapping_list_1.AutoMappingList.getSourceByName(propDef?.type ?? '');
             if (relationEntity && data[propName]) {
-                const cacheKey = `${entity.name}-${this.getIdOnEntity(new relationEntity(), data[propName])}`;
+                const cacheKey = `${relationEntity.name}-${this.getIdOnEntity(new relationEntity(), data[propName])}`;
                 if (cache.has(cacheKey)) {
-                    data[propName] = cache.get(cacheKey);
                     continue;
                 }
                 cache.set(cacheKey, data[propName]);
-                data[propName] = await this.loadRelationForEntity(this.getWhereByIdSchema(new relationEntity(), data[propName]), relationEntity, cache);
-                cache.set(cacheKey, data[propName]);
+                await this.loadRelationForEntity(this.getWhereByIdSchema(new relationEntity(), data[propName]), relationEntity, cache).then((response) => cache.set(cacheKey, response));
             }
         }
         return data;
@@ -411,35 +426,41 @@ class RepositoryBase {
     }
     async findById(id) {
         const data = await this.context().findFirst({
-            select: this.getSelectWithRelationsId(this._modelName.prototype.constructor),
-            where: this.getWhereByIdSchema(this._modelName.prototype.constructor, {
+            select: this.getSelectWithRelationsId(this.entityInstance),
+            where: this.getWhereByIdSchema(this.entityInstance, {
                 id,
             }),
         });
         if (!data)
             return null;
-        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, (0, proxy_1.createProxy)(data));
-        return this.createEntity(enrichedEntity);
+        const cache = new Map();
+        return this.enrichEntityWithRelations(this.entityInstance, (0, proxy_1.createProxy)(data), cache)
+            .then((response) => this.loadEntityFromCache(this.entityInstance, response, cache))
+            .then((response) => this.createEntity(response));
     }
     async findFirst(where) {
         const data = await this.context().findFirst({
-            select: this.getSelectWithRelationsId(this._modelName.prototype.constructor),
+            select: this.getSelectWithRelationsId(this.entityInstance),
             where,
         });
         if (!data)
             return null;
-        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, (0, proxy_1.createProxy)(data));
-        return this.createEntity(enrichedEntity);
+        const cache = new Map();
+        return this.enrichEntityWithRelations(this.entityInstance, (0, proxy_1.createProxy)(data), cache)
+            .then((response) => this.loadEntityFromCache(this.entityInstance, response, cache))
+            .then((response) => this.createEntity(response));
     }
     async findUnique(where) {
         const data = await this.context().findUnique({
-            select: this.getSelectWithRelationsId(this._modelName.prototype.constructor),
+            select: this.getSelectWithRelationsId(this.entityInstance),
             where,
         });
         if (!data)
             return null;
-        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, (0, proxy_1.createProxy)(data));
-        return this.createEntity(enrichedEntity);
+        const cache = new Map();
+        return this.enrichEntityWithRelations(this.entityInstance, (0, proxy_1.createProxy)(data), cache)
+            .then((response) => this.loadEntityFromCache(this.entityInstance, response, cache))
+            .then((response) => this.createEntity(response));
     }
     async findMany(where, pagination) {
         return this.context()

package/core/mapping/auto-mapping.service.d.ts

@@ -2,9 +2,15 @@ import { Type } from '@nestjs/common';
 import { AutoMappingProfile } from './auto-mapping-profile';
 export declare class AutoMappingService {
     private readonly _contextList;
+    private readonly _circularCutPolicy;
+    private createMapContext;
     constructor(automappingProfile: AutoMappingProfile);
     private getInstanceType;
     map<S, T>(data: any, source: Type<S>, target: Type<T>): T;
+    private getIdOnlyValue;
+    private shouldCutCircularMapping;
+    private getCutValue;
+    private mapWithContext;
     private getTarget;
     private mapNestedProp;
     private mapListToArray;

package/core/mapping/auto-mapping.service.js

@@ -17,6 +17,15 @@ const auto_mapping_list_1 = require("./auto-mapping-list");
 const auto_mapping_profile_1 = require("./auto-mapping-profile");
 let AutoMappingService = class AutoMappingService {
     _contextList = auto_mapping_list_1.AutoMappingList;
+    _circularCutPolicy = {
+        onCut: 'id-only',
+    };
+    createMapContext() {
+        return {
+            references: new WeakMap(),
+            targetPath: [],
+        };
+    }
     constructor(automappingProfile) {
         automappingProfile.profile();
     }
@@ -29,57 +38,105 @@ let AutoMappingService = class AutoMappingService {
         }
     }
     map(data, source, target) {
+        return this.mapWithContext(data, source, target, this.createMapContext());
+    }
+    getIdOnlyValue(data) {
+        if (!data || typeof data !== 'object') {
+            return data;
+        }
+        const id = data.id ?? data._id;
+        if (id !== undefined) {
+            return { id };
+        }
+        return null;
+    }
+    shouldCutCircularMapping(target, context) {
+        return context.targetPath.some((targetOnPath) => targetOnPath === target);
+    }
+    getCutValue(data) {
+        const onCut = this._circularCutPolicy.onCut;
+        if (onCut === 'null') {
+            return null;
+        }
+        if (onCut === 'omit') {
+            return undefined;
+        }
+        return this.getIdOnlyValue(data);
+    }
+    mapWithContext(data, source, target, context) {
+        if (!data || this.isPrimitiveType(data)) {
+            return data;
+        }
+        if (this.shouldCutCircularMapping(target, context)) {
+            return this.getCutValue(data);
+        }
+        const cachedByTarget = context.references.get(data);
+        const cachedTarget = cachedByTarget?.get(target);
+        if (cachedTarget) {
+            return cachedTarget;
+        }
         const { mapContext, propSourceContext, propTargetContext } = this._contextList.get(source, target);
         if (!mapContext) {
             throw new Error(`No mapping context found for ${source.name} to ${target.name}`);
         }
         const mappedTarget = new target.prototype.constructor();
-        propSourceContext?.props.forEach((propSource) => {
-            const value = data[propSource.name];
-            const compositionType = propSource.compositionType;
-            const compositionAction = propSource.compositionAction;
-            if (value !== undefined) {
-                const targetProp = propTargetContext?.props.find((tp) => tp.name === propSource.name);
-                if (targetProp) {
-                    const typeSource = (0, get_type_by_prop_1.getTypeByProp)(propSource);
-                    const typeTarget = (0, get_type_by_prop_1.getTypeByProp)(targetProp);
-                    const listToArray = typeSource === list_1.List.name &&
-                        typeTarget === Array.name &&
-                        value instanceof list_1.List;
-                    const arrayToList = typeSource === Array.name &&
-                        typeTarget === list_1.List.name &&
-                        value instanceof Array &&
-                        !!compositionType;
-                    const arrayToArray = typeSource === Array.name &&
-                        typeTarget === Array.name &&
-                        value instanceof Array &&
-                        !!compositionType;
-                    let mappedValue = value;
-                    if (listToArray) {
-                        mappedValue = this.mapListToArray(value);
-                    }
-                    else if (arrayToList) {
-                        mappedValue = this.mapArrayToList(value, this.getInstanceType(compositionType), compositionAction === 'onlySet');
-                    }
-                    else if (arrayToArray) {
-                        mappedValue = this.mapArrayToArray(value, this.getInstanceType(compositionType));
-                    }
-                    else {
-                        const propSourceInstance = this._contextList.getSourceByName(typeSource);
-                        if (propSourceInstance) {
-                            mappedValue = this.mapNestedProp(value, propSourceInstance);
+        if (typeof data === 'object') {
+            const cachedTargets = context.references.get(data) ?? new Map();
+            cachedTargets.set(target, mappedTarget);
+            context.references.set(data, cachedTargets);
+        }
+        context.targetPath.push(target);
+        try {
+            propSourceContext?.props.forEach((propSource) => {
+                const value = data[propSource.name];
+                const compositionType = propSource.compositionType;
+                const compositionAction = propSource.compositionAction;
+                if (value !== undefined) {
+                    const targetProp = propTargetContext?.props.find((tp) => tp.name === propSource.name);
+                    if (targetProp) {
+                        const typeSource = (0, get_type_by_prop_1.getTypeByProp)(propSource);
+                        const typeTarget = (0, get_type_by_prop_1.getTypeByProp)(targetProp);
+                        const listToArray = typeSource === list_1.List.name &&
+                            typeTarget === Array.name &&
+                            value instanceof list_1.List;
+                        const arrayToList = typeSource === Array.name &&
+                            typeTarget === list_1.List.name &&
+                            value instanceof Array &&
+                            !!compositionType;
+                        const arrayToArray = typeSource === Array.name &&
+                            typeTarget === Array.name &&
+                            value instanceof Array &&
+                            !!compositionType;
+                        let mappedValue = value;
+                        if (listToArray) {
+                            mappedValue = this.mapListToArray(value, context);
+                        }
+                        else if (arrayToList) {
+                            mappedValue = this.mapArrayToList(value, this.getInstanceType(compositionType), context, compositionAction === 'onlySet');
+                        }
+                        else if (arrayToArray) {
+                            mappedValue = this.mapArrayToArray(value, this.getInstanceType(compositionType), context);
+                        }
+                        else {
+                            const propSourceInstance = this._contextList.getSourceByName(typeSource);
+                            if (propSourceInstance) {
+                                mappedValue = this.mapNestedProp(value, propSourceInstance, context);
+                            }
                         }
+                        mappedTarget[targetProp.name] = mappedValue;
                     }
-                    mappedTarget[targetProp.name] = mappedValue;
                 }
-            }
-        });
-        propTargetContext?.props.forEach((prop) => {
-            const formMemberDefinition = mapContext.forMemberDifinitions?.find((def) => def[prop.name])?.[prop.name];
-            if (formMemberDefinition) {
-                mappedTarget[prop.name] = formMemberDefinition(data);
-            }
-        });
+            });
+            propTargetContext?.props.forEach((prop) => {
+                const formMemberDefinition = mapContext.forMemberDifinitions?.find((def) => def[prop.name])?.[prop.name];
+                if (formMemberDefinition) {
+                    mappedTarget[prop.name] = formMemberDefinition(data);
+                }
+            });
+        }
+        finally {
+            context.targetPath.pop();
+        }
         return mappedTarget;
     }
     getTarget(data, source) {
@@ -92,21 +149,21 @@ let AutoMappingService = class AutoMappingService {
         }
         return targets[0];
     }
-    mapNestedProp(data, source) {
-        return this.map(data, source.prototype.constructor, this.getTarget(data, source));
+    mapNestedProp(data, source, context) {
+        return this.mapWithContext(data, source.prototype.constructor, this.getTarget(data, source), context);
     }
-    mapListToArray(value) {
+    mapListToArray(value, context) {
         return value.toArray().map((item) => {
             const entityOnList = value.entityType?.prototype.constructor;
             if (entityOnList) {
-                return this.mapNestedProp(item, entityOnList) ?? {};
+                return this.mapNestedProp(item, entityOnList, context) ?? {};
             }
             return {};
         });
     }
-    mapArrayToList(value, compositionType, onlySet = true) {
+    mapArrayToList(value, compositionType, context, onlySet = true) {
         const list = new list_1.List(this.getTarget(value, compositionType.prototype.constructor));
-        const mappedValue = value.map((item) => this.mapNestedProp(item, compositionType.prototype.constructor) ?? {});
+        const mappedValue = value.map((item) => this.mapNestedProp(item, compositionType.prototype.constructor, context) ?? {});
         if (onlySet) {
             list.setList(mappedValue);
         }
@@ -115,8 +172,8 @@ let AutoMappingService = class AutoMappingService {
         }
         return list;
     }
-    mapArrayToArray(value, compositionType) {
-        return value.map((item) => this.mapNestedProp(item, compositionType.prototype.constructor) ?? {});
+    mapArrayToArray(value, compositionType, context) {
+        return value.map((item) => this.mapNestedProp(item, compositionType.prototype.constructor, context) ?? {});
     }
     isPrimitiveType(value) {
         switch (typeof value) {

package/core/utils/automap-cycle-context.d.ts

@@ -0,0 +1,6 @@
+import { Type } from '@nestjs/common';
+export interface AutomapContext {
+    references: WeakMap<object, any>;
+}
+export declare function createAutomapContext(): AutomapContext;
+export declare function mapEntityReference(value: any, EntityOnPropKey: Type<any>, context: AutomapContext, action: number): any;

package/core/utils/automap-cycle-context.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAutomapContext = createAutomapContext;
+exports.mapEntityReference = mapEntityReference;
+function createAutomapContext() {
+    return {
+        references: new WeakMap(),
+    };
+}
+function mapEntityReference(value, EntityOnPropKey, context, action) {
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const cachedEntity = context.references.get(value);
+    if (cachedEntity) {
+        return cachedEntity;
+    }
+    const entity = new EntityOnPropKey();
+    if (entity && typeof entity.automap === 'function') {
+        ;
+        entity._action = action;
+        context.references.set(value, entity);
+        entity.automap(value, context);
+    }
+    return entity;
+}

package/core/utils/hydrate-entity-from-cache.d.ts

@@ -0,0 +1,22 @@
+import { Type } from '@nestjs/common';
+export type GraphVisitState = 'loading' | 'loaded';
+export interface HydrateEntityFromCacheDependencies {
+    getAllProps(entity: Type<any>): Array<{
+        name: string;
+    }>;
+    getPropDefinitions(entity: Type<any>, propName: string): {
+        type?: string;
+    } | undefined;
+    getSourceByName(sourceName: string): Type<any> | undefined;
+    getListEntityType(entity: Type<any>, propName: string): Type<any> | undefined;
+    getIdOnEntity(entity: any, data: any): string;
+    createEntity(entity: Type<any>): any;
+}
+export interface HydrateEntityFromCacheParams {
+    entity: Type<any>;
+    data: any;
+    cache: Map<string, any>;
+    dependencies: HydrateEntityFromCacheDependencies;
+    visitState?: Map<string, GraphVisitState>;
+}
+export declare function hydrateEntityFromCache({ entity, data, cache, dependencies, visitState, }: HydrateEntityFromCacheParams): any;

package/core/utils/hydrate-entity-from-cache.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hydrateEntityFromCache = hydrateEntityFromCache;
+function mergeScalarProps(target, source) {
+    Object.keys(source || {}).forEach((key) => {
+        const value = source[key];
+        if (value === undefined) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            return;
+        }
+        if (value !== null && typeof value === 'object') {
+            return;
+        }
+        target[key] = value;
+    });
+}
+function getCacheKey(entity, data, dependencies) {
+    const entityId = dependencies.getIdOnEntity(dependencies.createEntity(entity), data);
+    return `${entity.name}-${entityId}`;
+}
+function hydrateEntityFromCache({ entity, data, cache, dependencies, visitState = new Map(), }) {
+    if (!data) {
+        return data;
+    }
+    const cacheKey = getCacheKey(entity, data, dependencies);
+    const sourceData = cache.get(cacheKey) ?? data;
+    let canonicalEntity = cache.get(cacheKey);
+    if (!canonicalEntity) {
+        canonicalEntity = sourceData;
+        cache.set(cacheKey, canonicalEntity);
+    }
+    mergeScalarProps(canonicalEntity, sourceData);
+    if (visitState.get(cacheKey) === 'loading') {
+        return canonicalEntity;
+    }
+    visitState.set(cacheKey, 'loading');
+    const allProps = dependencies.getAllProps(entity);
+    for (const prop of allProps) {
+        const propName = prop.name;
+        const propDefinition = dependencies.getPropDefinitions(entity, propName);
+        const sourcePropValue = sourceData[propName] ?? canonicalEntity[propName];
+        if (Array.isArray(sourcePropValue)) {
+            const listEntity = dependencies.getListEntityType(entity, propName);
+            if (!listEntity) {
+                canonicalEntity[propName] = sourcePropValue;
+                continue;
+            }
+            canonicalEntity[propName] = sourcePropValue.map((item) => hydrateEntityFromCache({
+                entity: listEntity,
+                data: item,
+                cache,
+                dependencies,
+                visitState,
+            }));
+            continue;
+        }
+        const relationEntity = dependencies.getSourceByName(propDefinition?.type ?? '');
+        if (relationEntity && sourcePropValue) {
+            canonicalEntity[propName] = hydrateEntityFromCache({
+                entity: relationEntity,
+                data: sourcePropValue,
+                cache,
+                dependencies,
+                visitState,
+            });
+            continue;
+        }
+        if (sourcePropValue !== undefined) {
+            canonicalEntity[propName] = sourcePropValue;
+        }
+    }
+    visitState.set(cacheKey, 'loaded');
+    return canonicalEntity;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalarx/nest",
-  "version": "3.1.28",
+  "version": "3.1.30",
   "description": "",
   "author": "Igor D. Rangel",
   "license": "MIT",