@koalarx/nest 1.18.10 → 1.18.12

package/core/database/entity.base.js

@@ -24,7 +24,7 @@ class EntityBase {
                     continue;
                 }
                 const propDefinitions = auto_mapping_list_1.AutoMappingList.getPropDefinitions(this.constructor.prototype.constructor, key);
-                const EntityOnPropKey = auto_mapping_list_1.AutoMappingList.getSourceByName(propDefinitions?.type);
+                const EntityOnPropKey = auto_mapping_list_1.AutoMappingList.getSourceByName(propDefinitions?.type ?? '');
                 if (Array.isArray(props[key]) && this[key] instanceof list_1.List) {
                     let value = props[key];
                     if (this[key].entityType) {

package/core/mapping/auto-mapping-class-context.d.ts

@@ -1,15 +1,16 @@
 import { Type } from '@nestjs/common';
 import { IComparable, IComparableId } from '../utils/interfaces/icomparable';
 import { List } from '../utils/list';
+export interface AutoMappingClassProp {
+    name: string;
+    type: () => Type<any> | ArrayConstructor;
+    compositionType?: () => Type<any> | ArrayConstructor;
+    compositionAction?: 'onlySet' | 'addTo';
+}
 export declare class AutoMappingClassContext implements IComparable<AutoMappingClassContext> {
     _id: IComparableId;
     source: Type<any>;
-    props: List<{
-        name: string;
-        type: any;
-        compositionType?: Type<any>;
-        compositionAction?: "onlySet" | "addTo";
-    }>;
+    props: List<AutoMappingClassProp>;
     constructor(source: Type<any>);
     equals(obj: AutoMappingClassContext): boolean;
 }

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

@@ -15,11 +15,11 @@ export declare class AutoMappingList {
     static get(source: Type<any>, target: Type<any>): AutoMappingGetContext;
     static getSourceByName(sourceName: string): Type<any> | undefined;
     static getPropDefinitions(source: Type<any>, propName: string): {
+        type: string;
         name: string;
-        type: any;
-        compositionType?: Type<any>;
+        compositionType?: () => Type<any> | ArrayConstructor;
         compositionAction?: "onlySet" | "addTo";
-    } | null | undefined;
+    } | undefined;
     static getTargets(source: Type<any>): Type<any>[];
     static addMappedProp(source: Type<any>, propName: string): void;
     static addExtendedPropsIntoSubClass(source: Type<any>): void;

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

@@ -40,7 +40,21 @@ class AutoMappingList {
     }
     static getPropDefinitions(source, propName) {
         this.initializeLists();
-        return this._mappedPropList.find((mp) => mp.source.name === source.name)?.props.find((prop) => prop.name === propName);
+        const prop = this._mappedPropList.find((mp) => mp.source.name === source.name)?.props.find((prop) => prop.name === propName);
+        if (!prop) {
+            return undefined;
+        }
+        let type;
+        try {
+            type = prop.type().name ?? prop.type.name ?? '';
+        }
+        catch {
+            type = prop.type.name ?? '';
+        }
+        return {
+            ...prop,
+            type,
+        };
     }
     static getTargets(source) {
         this.initializeLists();
@@ -60,10 +74,9 @@ class AutoMappingList {
             }
             this._mappedPropList.add(mappedClass);
         }
-        const metadata = Reflect.getMetadata('design:type', source.prototype, propName);
+        const type = Reflect.getMetadata('design:type', source.prototype, propName);
         const compositionType = Reflect.getMetadata('composition:type', source.prototype, propName);
         const compositionAction = Reflect.getMetadata('composition:action', source.prototype, propName);
-        const type = metadata?.name;
         mappedClass.props.add({
             name: propName,
             type,

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

@@ -5,7 +5,7 @@ const auto_mapping_list_1 = require("./auto-mapping-list");
 function AutoMap(config) {
     return function (target, propertyKey) {
         const isArray = config?.isArray;
-        let customMetadata = config?.type?.();
+        let customMetadata = config?.type;
         if (!customMetadata) {
             customMetadata = isArray ? Array : undefined;
         }

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

@@ -3,6 +3,8 @@ import { AutoMappingProfile } from './auto-mapping-profile';
 export declare class AutoMappingService {
     private readonly _contextList;
     constructor(automappingProfile: AutoMappingProfile);
+    private getType;
+    private getInstanceType;
     map<S, T>(data: any, source: Type<S>, target: Type<T>): T;
     private mapNestedProp;
     private mapListToArray;

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

@@ -19,6 +19,12 @@ let AutoMappingService = class AutoMappingService {
     constructor(automappingProfile) {
         automappingProfile.profile();
     }
+    getType(prop) {
+        return prop.type().name ?? prop.type.name;
+    }
+    getInstanceType(prop) {
+        return prop() ?? prop;
+    }
     map(data, source, target) {
         const { mapContext, propSourceContext, propTargetContext } = this._contextList.get(source, target);
         if (!mapContext) {
@@ -32,15 +38,17 @@ let AutoMappingService = class AutoMappingService {
             if (value !== undefined) {
                 const targetProp = propTargetContext?.props.find((tp) => tp.name === propSource.name);
                 if (targetProp) {
-                    const listToArray = propSource.type === list_1.List.name &&
-                        targetProp.type === Array.name &&
+                    const typeSource = this.getType(propSource);
+                    const typeTarget = this.getType(targetProp);
+                    const listToArray = typeSource === list_1.List.name &&
+                        typeTarget === Array.name &&
                         value instanceof list_1.List;
-                    const arrayToList = propSource.type === Array.name &&
-                        targetProp.type === list_1.List.name &&
+                    const arrayToList = typeSource === Array.name &&
+                        typeTarget === list_1.List.name &&
                         value instanceof Array &&
                         !!compositionType;
-                    const arrayToArray = propSource.type === Array.name &&
-                        targetProp.type === Array.name &&
+                    const arrayToArray = typeSource === Array.name &&
+                        typeTarget === Array.name &&
                         value instanceof Array &&
                         !!compositionType;
                     let mappedValue = value;
@@ -48,13 +56,13 @@ let AutoMappingService = class AutoMappingService {
                         mappedValue = this.mapListToArray(value);
                     }
                     else if (arrayToList) {
-                        mappedValue = this.mapArrayToList(value, compositionType, compositionAction === 'onlySet');
+                        mappedValue = this.mapArrayToList(value, this.getInstanceType(compositionType), compositionAction === 'onlySet');
                     }
                     else if (arrayToArray) {
-                        mappedValue = this.mapArrayToArray(value, compositionType);
+                        mappedValue = this.mapArrayToArray(value, this.getInstanceType(compositionType));
                     }
                     else {
-                        const propSourceInstance = this._contextList.getSourceByName(propSource.type);
+                        const propSourceInstance = this._contextList.getSourceByName(typeSource);
                         if (propSourceInstance) {
                             mappedValue = this.mapNestedProp(value, propSourceInstance);
                         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalarx/nest",
-  "version": "1.18.10",
+  "version": "1.18.12",
   "description": "",
   "repository": {
     "type": "git",