@koalarx/nest 0.0.9 → 1.0.0

package/core/koala-app.d.ts

@@ -1,23 +1,22 @@
 import { INestApplication, Type } from '@nestjs/common';
 import { BaseExceptionFilter } from '@nestjs/core';
-import { CronJob } from '../common/backgroud-services/cron-service/cron-job';
-import { EventHandler } from '../common/backgroud-services/event-service/event-handler';
+import { CronJob } from '../core/backgroud-services/cron-service/cron-job';
+import { EventHandler } from '../core/backgroud-services/event-service/event-handler';
+import { PrismaTransactionalClient } from './database/prisma-transactional-client';
 interface ApiDocConfig {
     endpoint: string;
     title: string;
+    ui?: 'swagger' | 'scalar';
     description?: string;
     externalDoc?: {
         message: string;
         url: string;
     };
     version: string;
-    accessDocWithCredentials?: {
-        username: string;
-        password: string;
-    };
     withAuthorization?: boolean;
 }
 type CronJobClass = string | symbol | Function | Type<CronJob>;
+type EventJobClass = string | symbol | Function | Type<EventHandler<any>>;
 export declare class KoalaApp {
     private readonly app;
     private _globalExceptionFilter;
@@ -28,13 +27,16 @@ export declare class KoalaApp {
     private _eventJobs;
     constructor(app: INestApplication<any>);
     addCronJob(job: CronJobClass): this;
-    addEventJob(eventJob: EventHandler<any>): this;
+    addEventJob(eventJob: EventJobClass): this;
     addCustomGlobalExceptionFilter(filter: BaseExceptionFilter): this;
     addCustomPrismaValidationExceptionFilter(filter: BaseExceptionFilter): this;
     addCustomDomainExceptionFilter(filter: BaseExceptionFilter): this;
     addCustomZodExceptionFilter(filter: BaseExceptionFilter): this;
-    includeSwagger(config: ApiDocConfig): this;
+    useDoc(config: ApiDocConfig): this;
     enableCors(): this;
+    setAppName(name: string): this;
+    setInternalUserName(name: string): this;
+    setDbTransactionContext(transactionContext: Type<PrismaTransactionalClient>): this;
     build(): Promise<INestApplication<any>>;
 }
 export {};

package/core/koala-app.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KoalaApp = void 0;
+const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const swagger_1 = require("@nestjs/swagger");
-const express_basic_auth_1 = require("express-basic-auth");
+const nestjs_api_reference_1 = require("@scalar/nestjs-api-reference");
+const expressBasicAuth = require("express-basic-auth");
 const domain_errors_filter_1 = require("../filters/domain-errors.filter");
 const global_exception_filter_1 = require("../filters/global-exception.filter");
 const prisma_validation_exception_filter_1 = require("../filters/prisma-validation-exception.filter");
 const zod_errors_filter_1 = require("../filters/zod-errors.filter");
+const koala_global_vars_1 = require("./koala-global-vars");
 const env_config_1 = require("./utils/env.config");
 class KoalaApp {
     app;
@@ -50,12 +53,16 @@ class KoalaApp {
         this._zodExceptionFilter = filter;
         return this;
     }
-    includeSwagger(config) {
-        if (env_config_1.EnvConfig.isEnvDevelop && config.accessDocWithCredentials) {
-            this.app.use([config.endpoint], (0, express_basic_auth_1.default)({
+    useDoc(config) {
+        const credentials = {
+            username: process.env.SWAGGER_USERNAME ?? '',
+            password: process.env.SWAGGER_PASSWORD ?? ''
+        };
+        if (env_config_1.EnvConfig.isEnvDevelop && credentials.username && credentials.password) {
+            this.app.use([config.endpoint], expressBasicAuth({
                 challenge: true,
                 users: {
-                    [config.accessDocWithCredentials.username]: config.accessDocWithCredentials.password,
+                    [credentials.username]: credentials.password
                 },
             }));
         }
@@ -73,7 +80,15 @@ class KoalaApp {
         }
         const document = swagger_1.SwaggerModule.createDocument(this.app, documentBuilder.build());
         const swaggerEndpoint = config.endpoint;
-        swagger_1.SwaggerModule.setup(swaggerEndpoint, this.app, document);
+        if (config.ui === 'scalar' && swaggerEndpoint === '/') {
+            throw new common_1.InternalServerErrorException("O endpoint de documentação não pode ser '/' para UI Scalar.");
+        }
+        swagger_1.SwaggerModule.setup(swaggerEndpoint, this.app, document, {
+            swaggerUiEnabled: config.ui !== 'scalar',
+        });
+        if (config.ui === 'scalar') {
+            this.app.use(swaggerEndpoint, (0, nestjs_api_reference_1.apiReference)({ spec: { content: document } }));
+        }
         return this;
     }
     enableCors() {
@@ -84,10 +99,28 @@ class KoalaApp {
         });
         return this;
     }
+    setAppName(name) {
+        koala_global_vars_1.KoalaGlobalVars.appName = name;
+        return this;
+    }
+    setInternalUserName(name) {
+        koala_global_vars_1.KoalaGlobalVars.internalUserName = name;
+        return this;
+    }
+    setDbTransactionContext(transactionContext) {
+        koala_global_vars_1.KoalaGlobalVars.dbTransactionContext = transactionContext;
+        return this;
+    }
     async build() {
         this.app.useGlobalFilters(this._globalExceptionFilter, this._prismaValidationExceptionFilter, this._domainExceptionFilter, this._zodExceptionFilter);
-        Promise.all(this._cronJobs.map((job) => this.app.resolve(job))).then((cronJobs) => cronJobs.forEach((job) => job.run()));
-        this._eventJobs.forEach((eventJob) => eventJob.setupSubscriptions());
+        const cronJobs = await Promise.all(this._cronJobs.map((job) => this.app.resolve(job)));
+        for (const cronJob of cronJobs) {
+            cronJob.start();
+        }
+        const eventJobs = await Promise.all(this._eventJobs.map((job) => this.app.resolve(job)));
+        for (const eventJob of eventJobs) {
+            eventJob.setupSubscriptions();
+        }
         return this.app;
     }
 }

package/core/koala-global-vars.d.ts

@@ -0,0 +1,7 @@
+import { Type } from "@nestjs/common";
+import { PrismaTransactionalClient } from "./database/prisma-transactional-client";
+export declare class KoalaGlobalVars {
+    static appName: string;
+    static internalUserName: string;
+    static dbTransactionContext?: Type<PrismaTransactionalClient>;
+}

package/core/koala-global-vars.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoalaGlobalVars = void 0;
+class KoalaGlobalVars {
+    static appName = 'koala-nest';
+    static internalUserName = 'internal';
+    static dbTransactionContext;
+}
+exports.KoalaGlobalVars = KoalaGlobalVars;

package/core/koala-nest-database.module.d.ts

@@ -6,9 +6,9 @@ export interface KoalaNestDatabaseRepositoryConfig {
     class: Type<RepositoryBase<any>>;
 }
 interface KoalaNestDatabaseModuleConfig {
-    repositories?: KoalaNestDatabaseRepositoryConfig[];
+    repositories: KoalaNestDatabaseRepositoryConfig[];
 }
 export declare class KoalaNestDatabaseModule {
-    static forRoot(config: KoalaNestDatabaseModuleConfig): DynamicModule;
+    static register(config: KoalaNestDatabaseModuleConfig): DynamicModule;
 }
 export {};

package/core/koala-nest-database.module.js

@@ -9,30 +9,30 @@ var KoalaNestDatabaseModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KoalaNestDatabaseModule = exports.PRISMA_TOKEN = void 0;
 const common_1 = require("@nestjs/common");
-const env_service_1 = require("../services/env/env.service");
-const prisma_service_1 = require("../services/prisma/prisma.service");
+const env_service_1 = require("../env/env.service");
+const prisma_service_1 = require("./database/prisma.service");
 exports.PRISMA_TOKEN = 'PRISMA_SERVICE_TOKEN';
 let KoalaNestDatabaseModule = exports.KoalaNestDatabaseModule = KoalaNestDatabaseModule_1 = class KoalaNestDatabaseModule {
-    static forRoot(config) {
+    static register(config) {
+        const repositoriesToExport = config.repositories?.map((repository) => repository.interface) ?? [];
+        const repositoriesToProvide = config.repositories?.map((repository) => ({
+            provide: repository.interface,
+            useClass: repository.class,
+        })) ?? [];
         return {
             module: KoalaNestDatabaseModule_1,
-            providers: config.repositories?.map((repository) => ({
-                provide: repository.interface,
-                useClass: repository.class,
-            })),
-            exports: config.repositories?.map((repository) => repository.interface),
+            providers: [
+                {
+                    provide: exports.PRISMA_TOKEN,
+                    useClass: prisma_service_1.PrismaService,
+                },
+                ...repositoriesToProvide,
+                env_service_1.EnvService,
+            ],
+            exports: [exports.PRISMA_TOKEN, ...repositoriesToExport],
         };
     }
 };
 exports.KoalaNestDatabaseModule = KoalaNestDatabaseModule = KoalaNestDatabaseModule_1 = __decorate([
-    (0, common_1.Module)({
-        providers: [
-            {
-                provide: exports.PRISMA_TOKEN,
-                useClass: prisma_service_1.PrismaService,
-            },
-            env_service_1.EnvService,
-        ],
-        exports: [exports.PRISMA_TOKEN],
-    })
+    (0, common_1.Module)({})
 ], KoalaNestDatabaseModule);

package/core/koala-nest-http.module.d.ts

@@ -1,12 +1,12 @@
-import { DynamicModule, MiddlewareConsumer, NestMiddleware, NestModule, Provider, Type } from '@nestjs/common';
-import { AutomapperProfile } from 'automapper-nestjs';
+import { DynamicModule, MiddlewareConsumer, NestMiddleware, NestModule, Type } from '@nestjs/common';
+import { AutoMappingProfile } from './mapping/auto-mapping-profile';
 interface KoalaNestHttpModuleConfig {
-    automapperProfile: Provider<AutomapperProfile>;
-    middlewares: Type<NestMiddleware>[];
+    automapperProfile: Type<AutoMappingProfile>;
+    middlewares?: Type<NestMiddleware>[];
 }
 export declare class KoalaNestHttpModule implements NestModule {
     private static _config;
-    static forRoot(config: KoalaNestHttpModuleConfig): DynamicModule;
+    static register(config: KoalaNestHttpModuleConfig): DynamicModule;
     configure(consumer: MiddlewareConsumer): void;
 }
 export {};

package/core/koala-nest-http.module.js

@@ -9,30 +9,24 @@ var KoalaNestHttpModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KoalaNestHttpModule = void 0;
 const common_1 = require("@nestjs/common");
-const automapper_classes_1 = require("automapper-classes");
-const automapper_nestjs_1 = require("automapper-nestjs");
-const env_service_1 = require("../services/env/env.service");
+const env_service_1 = require("../env/env.service");
+const auto_mapping_module_1 = require("./mapping/auto-mapping.module");
 let KoalaNestHttpModule = exports.KoalaNestHttpModule = class KoalaNestHttpModule {
     static { KoalaNestHttpModule_1 = this; }
     static _config;
-    static forRoot(config) {
+    static register(config) {
         this._config = config;
         return {
             module: KoalaNestHttpModule_1,
-            providers: [config.automapperProfile],
+            imports: [auto_mapping_module_1.AutoMappingModule.register(config.automapperProfile)],
+            providers: [env_service_1.EnvService],
+            exports: [auto_mapping_module_1.AutoMappingModule],
         };
     }
     configure(consumer) {
-        KoalaNestHttpModule_1._config.middlewares.forEach((middleware) => consumer.apply(middleware).forRoutes('*'));
+        KoalaNestHttpModule_1._config.middlewares?.forEach((middleware) => consumer.apply(middleware).forRoutes('*'));
     }
 };
 exports.KoalaNestHttpModule = KoalaNestHttpModule = KoalaNestHttpModule_1 = __decorate([
-    (0, common_1.Module)({
-        imports: [
-            automapper_nestjs_1.AutomapperModule.forRoot({
-                strategyInitializer: (0, automapper_classes_1.classes)(),
-            }),
-        ],
-        providers: [env_service_1.EnvService],
-    })
+    (0, common_1.Module)({})
 ], KoalaNestHttpModule);

package/core/koala-nest.module.d.ts

@@ -1,13 +1,11 @@
 import { DynamicModule, Provider } from '@nestjs/common';
 import { ZodType } from 'zod';
 import { ILoggingService } from '../services/logging/ilogging.service';
-import { KoalaNestDatabaseRepositoryConfig } from './koala-nest-database.module';
 interface KoalaNestModuleConfig {
     logging?: Provider<ILoggingService>;
     env?: ZodType;
-    repositories?: KoalaNestDatabaseRepositoryConfig[];
 }
 export declare class KoalaNestModule {
-    static forRoot({ env, logging, repositories, }: KoalaNestModuleConfig): DynamicModule;
+    static register(config?: KoalaNestModuleConfig): DynamicModule;
 }
 export {};

package/core/koala-nest.module.js

@@ -10,45 +10,39 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.KoalaNestModule = void 0;
 const common_1 = require("@nestjs/common");
 const config_1 = require("@nestjs/config");
-const env_1 = require("../services/env/env");
-const env_service_1 = require("../services/env/env.service");
+const env_1 = require("../env/env");
+const env_module_1 = require("../env/env.module");
+const env_service_1 = require("../env/env.service");
 const ilogging_service_1 = require("../services/logging/ilogging.service");
 const logging_service_1 = require("../services/logging/logging.service");
 const iredis_service_1 = require("../services/redis/iredis.service");
 const redis_service_1 = require("../services/redis/redis.service");
 const ired_lock_service_1 = require("../services/redlock/ired-lock.service");
 const red_lock_service_1 = require("../services/redlock/red-lock.service");
-const koala_nest_database_module_1 = require("./koala-nest-database.module");
-const env_module_1 = require("../services/env/env.module");
 let KoalaNestModule = exports.KoalaNestModule = KoalaNestModule_1 = class KoalaNestModule {
-    static forRoot({ env, logging, repositories, }) {
+    static register(config) {
         return {
             module: KoalaNestModule_1,
             imports: [
                 config_1.ConfigModule.forRoot({
-                    validate: (envData) => (env ?? env_1.envSchema).parse(envData),
+                    validate: (envData) => (config?.env ?? env_1.envSchema).parse(envData),
                     isGlobal: true,
                 }),
-                koala_nest_database_module_1.KoalaNestDatabaseModule.forRoot({
-                    repositories,
-                }),
+                env_module_1.EnvModule,
             ],
             providers: [
                 {
                     provide: ilogging_service_1.ILoggingService,
-                    useValue: logging ?? logging_service_1.LoggingService,
+                    useValue: config?.logging ?? logging_service_1.LoggingService,
                 },
+                { provide: iredis_service_1.IRedisService, useClass: redis_service_1.RedisService },
+                { provide: ired_lock_service_1.IRedLockService, useClass: red_lock_service_1.RedLockService },
+                env_service_1.EnvService,
             ],
+            exports: [ilogging_service_1.ILoggingService, iredis_service_1.IRedisService, ired_lock_service_1.IRedLockService],
         };
     }
 };
 exports.KoalaNestModule = KoalaNestModule = KoalaNestModule_1 = __decorate([
-    (0, common_1.Module)({
-        imports: [env_module_1.EnvModule],
-        providers: [
-            { provide: iredis_service_1.IRedisService, useClass: redis_service_1.RedisService },
-            { provide: ired_lock_service_1.IRedLockService, useClass: red_lock_service_1.RedLockService },
-            env_service_1.EnvService,
-        ],
-    })
+    (0, common_1.Module)({})
 ], KoalaNestModule);

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

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

package/core/mapping/auto-mapping-class-context.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMappingClassContext = void 0;
+const list_1 = require("../utils/list");
+const crypto_1 = require("crypto");
+class AutoMappingClassContext {
+    _id;
+    source;
+    props = new list_1.List();
+    constructor(source) {
+        this._id = (0, crypto_1.randomUUID)();
+        this.source = source;
+    }
+    equals(obj) {
+        return obj._id === this._id && this.source instanceof obj.source;
+    }
+}
+exports.AutoMappingClassContext = AutoMappingClassContext;

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

@@ -0,0 +1,11 @@
+import { Type } from '@nestjs/common';
+import { IComparable, IComparableId } from '../utils/interfaces/icomparable';
+import { ForMemberDefinition } from './for-member';
+export declare class AutoMappingContext implements IComparable<AutoMappingContext> {
+    source: Type<any>;
+    target: Type<any>;
+    forMemberDifinitions: ForMemberDefinition<any, any>;
+    _id: IComparableId;
+    constructor(source: Type<any>, target: Type<any>, forMemberDifinitions: ForMemberDefinition<any, any>);
+    equals(obj: AutoMappingContext): boolean;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMappingContext = void 0;
+const node_crypto_1 = require("node:crypto");
+class AutoMappingContext {
+    source;
+    target;
+    forMemberDifinitions;
+    _id;
+    constructor(source, target, forMemberDifinitions) {
+        this.source = source;
+        this.target = target;
+        this.forMemberDifinitions = forMemberDifinitions;
+        this._id = (0, node_crypto_1.randomUUID)();
+        this.source = source;
+        this.target = target;
+    }
+    equals(obj) {
+        return (obj._id === this._id &&
+            this.source instanceof obj.source &&
+            this.target instanceof obj.target);
+    }
+}
+exports.AutoMappingContext = AutoMappingContext;

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

@@ -0,0 +1,18 @@
+import { Type } from '@nestjs/common';
+import { AutoMappingContext } from './auto-mapping-context';
+import { AutoMappingClassContext } from './auto-mapping-class-context';
+import { ForMemberDefinition } from './for-member';
+interface AutoMappingGetContext {
+    mapContext: AutoMappingContext | null;
+    propSourceContext: AutoMappingClassContext | null;
+    propTargetContext: AutoMappingClassContext | null;
+}
+export declare class AutoMappingList {
+    private static _mappedPropList;
+    private static _mappingProfileList;
+    static add(source: Type<any>, target: Type<any>, ...forMember: ForMemberDefinition<any, any>): void;
+    static get(source: Type<any>, target: Type<any>): AutoMappingGetContext;
+    static getTargets(source: Type<any>): Type<any>[];
+    static addMappedProp(source: Type<any>, propName: string): void;
+}
+export {};

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMappingList = void 0;
+const list_1 = require("../utils/list");
+const auto_mapping_context_1 = require("./auto-mapping-context");
+const auto_mapping_class_context_1 = require("./auto-mapping-class-context");
+class AutoMappingList {
+    static _mappedPropList = new list_1.List(auto_mapping_class_context_1.AutoMappingClassContext);
+    static _mappingProfileList = new list_1.List(auto_mapping_context_1.AutoMappingContext);
+    static add(source, target, ...forMember) {
+        this._mappingProfileList.add(new auto_mapping_context_1.AutoMappingContext(source, target, forMember));
+        this._mappedPropList.add(new auto_mapping_class_context_1.AutoMappingClassContext(source));
+        this._mappedPropList.add(new auto_mapping_class_context_1.AutoMappingClassContext(target));
+    }
+    static get(source, target) {
+        return {
+            mapContext: this._mappingProfileList.find((mp) => mp.source === source && mp.target === target),
+            propSourceContext: this._mappedPropList.find((mp) => mp.source === source),
+            propTargetContext: this._mappedPropList.find((mp) => mp.source === target),
+        };
+    }
+    static getTargets(source) {
+        return this._mappingProfileList
+            .filter((mp) => mp.source === source)
+            .map((mp) => mp.target)
+            .toArray();
+    }
+    static addMappedProp(source, propName) {
+        let mappedClass = this._mappedPropList.find((mp) => mp.source === source);
+        if (!mappedClass) {
+            mappedClass = new auto_mapping_class_context_1.AutoMappingClassContext(source);
+            this._mappedPropList.add(mappedClass);
+        }
+        const metadata = 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,
+            compositionType,
+            compositionAction,
+        });
+    }
+}
+exports.AutoMappingList = AutoMappingList;

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

@@ -0,0 +1,3 @@
+export declare abstract class AutoMappingProfile {
+    abstract profile(): void;
+}

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMappingProfile = void 0;
+class AutoMappingProfile {
+}
+exports.AutoMappingProfile = AutoMappingProfile;

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

@@ -0,0 +1,9 @@
+import { Type } from '@nestjs/common';
+interface AutoMapConfig<T> {
+    type?: Type<T>;
+    isArray?: boolean | {
+        addTo: boolean;
+    };
+}
+export declare function AutoMap<T>(config?: AutoMapConfig<T>): (target: any, propertyKey: string) => void;
+export {};

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMap = void 0;
+const auto_mapping_list_1 = require("./auto-mapping-list");
+function AutoMap(config) {
+    return function (target, propertyKey) {
+        const isArray = config?.isArray;
+        let customMetadata = config?.type;
+        if (!customMetadata) {
+            customMetadata = isArray ? Array : undefined;
+        }
+        if (customMetadata) {
+            if (isArray) {
+                Reflect.defineMetadata('composition:type', customMetadata, target, propertyKey);
+                Reflect.defineMetadata('composition:action', `${isArray === true || !isArray.addTo ? 'onlySet' : 'addTo'}`, target, propertyKey);
+                if (customMetadata !== Array) {
+                    customMetadata = Array;
+                }
+            }
+            if (!Reflect.getMetadata('design:type', target, propertyKey) || !isArray) {
+                Reflect.defineMetadata('design:type', customMetadata, target, propertyKey);
+            }
+        }
+        auto_mapping_list_1.AutoMappingList.addMappedProp(target.constructor, propertyKey);
+    };
+}
+exports.AutoMap = AutoMap;

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

@@ -0,0 +1,5 @@
+import { DynamicModule, Type } from '@nestjs/common';
+import { AutoMappingProfile } from './auto-mapping-profile';
+export declare class AutoMappingModule {
+    static register(profile: Type<AutoMappingProfile>): DynamicModule;
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var AutoMappingModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMappingModule = void 0;
+const common_1 = require("@nestjs/common");
+const auto_mapping_profile_1 = require("./auto-mapping-profile");
+const auto_mapping_service_1 = require("./auto-mapping.service");
+let AutoMappingModule = exports.AutoMappingModule = AutoMappingModule_1 = class AutoMappingModule {
+    static register(profile) {
+        return {
+            module: AutoMappingModule_1,
+            providers: [
+                { provide: auto_mapping_profile_1.AutoMappingProfile, useClass: profile },
+                auto_mapping_service_1.AutoMappingService,
+            ],
+            exports: [auto_mapping_service_1.AutoMappingService],
+        };
+    }
+};
+exports.AutoMappingModule = AutoMappingModule = AutoMappingModule_1 = __decorate([
+    (0, common_1.Module)({})
+], AutoMappingModule);

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

@@ -0,0 +1,10 @@
+import { Type } from '@nestjs/common';
+import { AutoMappingProfile } from './auto-mapping-profile';
+export declare class AutoMappingService {
+    private readonly _contextList;
+    constructor(automappingProfile: AutoMappingProfile);
+    map<S, T>(data: any, source: Type<S>, target: Type<T>): T;
+    private mapNestedProp;
+    private mapListToArray;
+    private mapArrayToList;
+}