@koalarx/nest 3.1.29 → 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/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/package.json

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