@nest-omni/core 3.1.1-20 → 3.1.1-22

package/common/abstract.entity.d.ts

@@ -1,16 +1,9 @@
 import type { AbstractDto, AbstractTranslationDto } from './dto/abstract.dto';
 import { LanguageCode } from '../constants';
-import type { Constructor } from './types';
 export declare abstract class AbstractDtoEntity<DTO, O = never> {
     translations?: AbstractTranslationEntity[];
     toDto(options?: O): DTO;
 }
-export declare function WithDto<Entity, DTO, O = never>(): {
-    new (): {
-        dtoClass?: Constructor<DTO, [Entity, O]>;
-        toDto(this: Entity, options?: O): DTO;
-    };
-};
 export declare abstract class AbstractBaseEntity<DTO, O> extends AbstractDtoEntity<DTO, O> {
     createdAt: Date;
     updatedAt: Date;

package/common/abstract.entity.js

@@ -10,7 +10,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractUuidPrimaryEntity = exports.AbstractTranslationEntity = exports.AbstractEntity = exports.AbstractBaseEntity = exports.AbstractDtoEntity = void 0;
-exports.WithDto = WithDto;
 const typeorm_1 = require("typeorm");
 const decorators_1 = require("../decorators");
 const constants_1 = require("../constants");
@@ -25,17 +24,6 @@ class AbstractDtoEntity {
     }
 }
 exports.AbstractDtoEntity = AbstractDtoEntity;
-function WithDto() {
-    return class Base {
-        toDto(options) {
-            const dtoClass = this.dtoClass || Object.getPrototypeOf(this).dtoClass;
-            if (!dtoClass) {
-                throw new Error(`You need to use @UseDto on class (${this.constructor.name}) be able to call toDto function`);
-            }
-            return new dtoClass(this, options);
-        }
-    };
-}
 class AbstractBaseEntity extends AbstractDtoEntity {
 }
 exports.AbstractBaseEntity = AbstractBaseEntity;

package/common/dto/dto-container.d.ts

@@ -0,0 +1,9 @@
+export declare class DtoContainer {
+    private static instance;
+    private container;
+    static getInstance(): DtoContainer;
+    static useContainer(container: any): void;
+    static get<T = any>(serviceToken: string | symbol | any): Promise<T | null>;
+    static isInitialized(): boolean;
+    static reset(): void;
+}

package/common/dto/dto-container.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtoContainer = void 0;
+class DtoContainer {
+    constructor() {
+        this.container = null;
+    }
+    static getInstance() {
+        if (!DtoContainer.instance) {
+            DtoContainer.instance = new DtoContainer();
+        }
+        return DtoContainer.instance;
+    }
+    static useContainer(container) {
+        DtoContainer.getInstance().container = container;
+    }
+    static get(serviceToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = DtoContainer.getInstance();
+            if (!instance.container) {
+                console.warn('DTO Container not initialized. Please call DtoContainer.useContainer(container) in your bootstrap.');
+                return null;
+            }
+            try {
+                if (typeof instance.container.get === 'function') {
+                    return yield instance.container.get(serviceToken);
+                }
+                else if (typeof instance.container.resolve === 'function') {
+                    return yield instance.container.resolve(serviceToken);
+                }
+                else if (typeof instance.container[serviceToken] === 'function') {
+                    return instance.container[serviceToken];
+                }
+                console.warn(`Unable to resolve service: ${String(serviceToken)}`);
+                return null;
+            }
+            catch (error) {
+                console.warn(`Failed to resolve service: ${String(serviceToken)}`, error instanceof Error ? error.message : error);
+                return null;
+            }
+        });
+    }
+    static isInitialized() {
+        return DtoContainer.getInstance().container !== null;
+    }
+    static reset() {
+        DtoContainer.getInstance().container = null;
+    }
+}
+exports.DtoContainer = DtoContainer;

package/common/dto/dto-decorators.d.ts

@@ -0,0 +1,18 @@
+import { Constructor } from '../types';
+import { TransformFnParams } from 'class-transformer';
+export interface ExtendedTransformFnParams extends TransformFnParams {
+    context?: any;
+}
+export declare const DTO_SERVICE_KEY = "dto:service-name";
+export declare function DtoService(serviceName?: string): ClassDecorator;
+export declare const DTO_REQUIRED_SERVICES_KEY = "dto:required-services";
+export declare function UseServices(...serviceTokens: Array<string | Constructor<any>>): ClassDecorator;
+export declare const DTO_ENTITY_KEY = "dto:entity";
+export declare function Dto(entityClass: Constructor<any>): ClassDecorator;
+export interface DtoFieldOptions {
+    source?: string;
+    transform?: (value: any) => any;
+}
+export declare function DtoField(source?: string, transform?: (value: any) => any): PropertyDecorator;
+export declare function DtoField(options?: DtoFieldOptions): PropertyDecorator;
+export declare function DtoComputed(computeFn: (entity: any, context?: any) => any): PropertyDecorator;

package/common/dto/dto-decorators.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DTO_ENTITY_KEY = exports.DTO_REQUIRED_SERVICES_KEY = exports.DTO_SERVICE_KEY = void 0;
+exports.DtoService = DtoService;
+exports.UseServices = UseServices;
+exports.Dto = Dto;
+exports.DtoField = DtoField;
+exports.DtoComputed = DtoComputed;
+const common_1 = require("@nestjs/common");
+exports.DTO_SERVICE_KEY = 'dto:service-name';
+function DtoService(serviceName) {
+    return function (target) {
+        const name = serviceName || target.name;
+        (0, common_1.SetMetadata)(exports.DTO_SERVICE_KEY, name)(target);
+    };
+}
+exports.DTO_REQUIRED_SERVICES_KEY = 'dto:required-services';
+function UseServices(...serviceTokens) {
+    return function (target) {
+        const tokens = serviceTokens.map(token => {
+            if (typeof token === 'string') {
+                return token;
+            }
+            return token.name.charAt(0).toLowerCase() + token.name.slice(1);
+        });
+        (0, common_1.SetMetadata)(exports.DTO_REQUIRED_SERVICES_KEY, tokens)(target);
+    };
+}
+exports.DTO_ENTITY_KEY = 'dto:entity';
+function Dto(entityClass) {
+    return function (target) {
+        (0, common_1.SetMetadata)(exports.DTO_ENTITY_KEY, entityClass)(target);
+    };
+}
+function DtoField(sourceOrOptions, transform) {
+    const options = typeof sourceOrOptions === 'string'
+        ? { source: sourceOrOptions, transform }
+        : sourceOrOptions || {};
+    return function (target, propertyKey) {
+        const fields = Reflect.getMetadata('dto:fields', target.constructor) || [];
+        fields.push({
+            property: propertyKey,
+            source: options.source || propertyKey,
+            transform: options.transform,
+        });
+        Reflect.defineMetadata('dto:fields', fields, target.constructor);
+    };
+}
+function DtoComputed(computeFn) {
+    return function (target, propertyKey) {
+        const fields = Reflect.getMetadata('dto:fields', target.constructor) || [];
+        fields.push({
+            property: propertyKey,
+            computeFn,
+            isComputed: true,
+        });
+        Reflect.defineMetadata('dto:fields', fields, target.constructor);
+    };
+}

package/common/dto/dto-extensions.d.ts

@@ -0,0 +1,12 @@
+import { Constructor } from '../types';
+declare global {
+    interface Array<T> {
+        toDto<DtoType>(dtoClass: Constructor<DtoType>, context?: any): Promise<DtoType[]>;
+    }
+}
+declare module 'typeorm' {
+    interface SelectQueryBuilder<Entity> {
+        toDtoPage<DtoType>(pageOptionsDto: any, dtoClass: Constructor<DtoType>, context?: any): Promise<any>;
+    }
+}
+export declare function transformEntityToDto<EntityType, DtoType>(entity: EntityType, dtoClass: Constructor<DtoType>, context?: any): Promise<DtoType>;

package/common/dto/dto-extensions.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformEntityToDto = transformEntityToDto;
+const typeorm_1 = require("typeorm");
+const dto_transformer_1 = require("./dto-transformer");
+Array.prototype.toDto = function (dtoClass, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this || this.length === 0) {
+            return [];
+        }
+        return yield dto_transformer_1.DtoTransformer.transformArray(this, dtoClass, context);
+    });
+};
+function transformEntityToDto(entity, dtoClass, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!entity) {
+            throw new Error('Cannot transform null or undefined to DTO');
+        }
+        return yield dto_transformer_1.DtoTransformer.transform(entity, dtoClass, context);
+    });
+}
+typeorm_1.SelectQueryBuilder.prototype.toDtoPage = function (pageOptionsDto, dtoClass, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const page = pageOptionsDto.page || 1;
+        const pageSize = pageOptionsDto.pageSize || 10;
+        const skip = (page - 1) * pageSize;
+        const totalItems = yield this.getCount();
+        const entities = yield this.skip(skip).take(pageSize).getMany();
+        if (entities.length > 0) {
+            console.log('Raw entity sample:', JSON.stringify(entities[0], null, 2));
+        }
+        const data = yield entities.toDto(dtoClass, context);
+        if (data.length > 0) {
+            console.log('Converted DTO sample:', JSON.stringify(data[0], null, 2));
+        }
+        const itemCount = totalItems;
+        const pageCount = Math.ceil(itemCount / pageSize);
+        const hasPreviousPage = page > 1;
+        const hasNextPage = page < pageCount;
+        return {
+            data,
+            itemCount,
+            page,
+            pageCount,
+            hasPreviousPage,
+            hasNextPage,
+        };
+    });
+};

package/common/dto/dto-service-accessor.d.ts

@@ -0,0 +1,7 @@
+import { Constructor } from '../types';
+export declare class DtoServiceAccessor {
+    static getService<T = any>(serviceToken: string | symbol | Constructor<any>): Promise<T | null>;
+    static getServices<T = any>(serviceTokens: Array<string | symbol | Constructor<any>>): Promise<Record<string, T>>;
+    static getServicesForDto(dtoClass: Constructor<any>): Promise<Record<string, any>>;
+    static isInitialized(): boolean;
+}

package/common/dto/dto-service-accessor.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtoServiceAccessor = void 0;
+const dto_container_1 = require("./dto-container");
+class DtoServiceAccessor {
+    static getService(serviceToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield dto_container_1.DtoContainer.get(serviceToken);
+        });
+    }
+    static getServices(serviceTokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const services = {};
+            const promises = serviceTokens.map((token) => __awaiter(this, void 0, void 0, function* () {
+                const serviceName = typeof token === 'string'
+                    ? token
+                    : token.name || String(token);
+                const service = yield dto_container_1.DtoContainer.get(token);
+                if (service) {
+                    services[serviceName] = service;
+                }
+            }));
+            yield Promise.all(promises);
+            return services;
+        });
+    }
+    static getServicesForDto(dtoClass) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const serviceTokens = Reflect.getMetadata('dto:required-services', dtoClass) || [];
+            if (serviceTokens.length === 0) {
+                return {};
+            }
+            return yield DtoServiceAccessor.getServices(serviceTokens);
+        });
+    }
+    static isInitialized() {
+        return dto_container_1.DtoContainer.isInitialized();
+    }
+}
+exports.DtoServiceAccessor = DtoServiceAccessor;

package/common/dto/dto-transformer.d.ts

@@ -0,0 +1,11 @@
+import { Constructor } from '../types';
+export interface DtoTransformContext {
+    user?: any;
+    request?: any;
+    services?: Record<string, any>;
+    [key: string]: any;
+}
+export declare class DtoTransformer {
+    static transform<EntityType, DtoType>(entity: EntityType, dtoClass: Constructor<DtoType>, context?: DtoTransformContext): Promise<DtoType>;
+    static transformArray<EntityType, DtoType>(entities: EntityType[], dtoClass: Constructor<DtoType>, context?: DtoTransformContext): Promise<DtoType[]>;
+}

package/common/dto/dto-transformer.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtoTransformer = void 0;
+const class_transformer_1 = require("class-transformer");
+const dto_service_accessor_1 = require("./dto-service-accessor");
+class DtoTransformer {
+    static transform(entity, dtoClass, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const services = yield dto_service_accessor_1.DtoServiceAccessor.getServicesForDto(dtoClass);
+            const options = {
+                excludeExtraneousValues: false,
+                exposeUnsetFields: true,
+                enableImplicitConversion: true,
+                enableCircularCheck: true,
+                ignoreDecorators: false,
+                context: Object.assign(Object.assign({}, context), { services }),
+            };
+            return (0, class_transformer_1.plainToInstance)(dtoClass, entity, options);
+        });
+    }
+    static transformArray(entities, dtoClass, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!entities || entities.length === 0) {
+                return [];
+            }
+            const services = yield dto_service_accessor_1.DtoServiceAccessor.getServicesForDto(dtoClass);
+            const options = {
+                excludeExtraneousValues: false,
+                exposeUnsetFields: true,
+                enableImplicitConversion: true,
+                enableCircularCheck: true,
+                ignoreDecorators: false,
+                context: Object.assign(Object.assign({}, context), { services }),
+            };
+            const transformPromises = entities.map(entity => (0, class_transformer_1.plainToInstance)(dtoClass, entity, options));
+            return Promise.all(transformPromises);
+        });
+    }
+}
+exports.DtoTransformer = DtoTransformer;

package/common/dto/index.d.ts

@@ -4,3 +4,9 @@ export * from './create-translation.dto';
 export * from './page.dto';
 export * from './page-meta.dto';
 export * from './page-options.dto';
+export * from './dto-service-accessor';
+export * from './dto-decorators';
+export * from './dto-transformer';
+export * from './dto-extensions';
+export * from './dto-container';
+import './dto-extensions';

package/common/dto/index.js

@@ -20,3 +20,9 @@ __exportStar(require("./create-translation.dto"), exports);
 __exportStar(require("./page.dto"), exports);
 __exportStar(require("./page-meta.dto"), exports);
 __exportStar(require("./page-options.dto"), exports);
+__exportStar(require("./dto-service-accessor"), exports);
+__exportStar(require("./dto-decorators"), exports);
+__exportStar(require("./dto-transformer"), exports);
+__exportStar(require("./dto-extensions"), exports);
+__exportStar(require("./dto-container"), exports);
+require("./dto-extensions");

package/decorators/api-paginated-response.decorator.d.ts

@@ -0,0 +1,2 @@
+import { ApiResponseOptions } from '@nestjs/swagger';
+export declare function ApiPaginatedResponse<T extends new (...args: any[]) => any>(entityClass: T, options?: Omit<ApiResponseOptions, 'type'>): MethodDecorator;

package/decorators/api-paginated-response.decorator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPaginatedResponse = ApiPaginatedResponse;
+const swagger_1 = require("@nestjs/swagger");
+const paginated_response_decorator_1 = require("./paginated-response.decorator");
+function ApiPaginatedResponse(entityClass, options) {
+    const ResponseDto = (0, paginated_response_decorator_1.createPaginatedResponseDto)(entityClass);
+    return (0, swagger_1.ApiResponse)(Object.assign(Object.assign({}, options), { type: ResponseDto }));
+}

package/decorators/field.decorators.js

@@ -383,6 +383,7 @@ function FQDNFieldOptional(options = {}) {
     return (0, common_1.applyDecorators)((0, validator_decorators_1.IsEmptyable)(), FQDNField(Object.assign({ required: false }, options)));
 }
 function DateField(options = {}) {
+    var _a;
     const decorators = [
         (0, class_transformer_1.Type)(() => Date),
         (0, class_validator_1.IsDate)({ message: (0, nestjs_i18n_1.i18nValidationMessage)('validation.IS_DATE') }),
@@ -406,7 +407,8 @@ function DateField(options = {}) {
         }));
     }
     if (options.swagger !== false) {
-        decorators.push((0, swagger_1.ApiProperty)(Object.assign({ type: Date }, options)));
+        const swaggerOptions = Object.assign({ type: Date, example: (_a = options.example) !== null && _a !== void 0 ? _a : new Date() }, options);
+        decorators.push((0, swagger_1.ApiProperty)(swaggerOptions));
     }
     return (0, common_1.applyDecorators)(...decorators);
 }

package/decorators/index.d.ts

@@ -10,3 +10,5 @@ export * from './translate.decorator';
 export * from './use-dto.decorator';
 export * from './validator.decorators';
 export * from './controller.decorator';
+export * from './api-paginated-response.decorator';
+export * from './paginated-response.decorator';

package/decorators/index.js

@@ -26,3 +26,5 @@ __exportStar(require("./translate.decorator"), exports);
 __exportStar(require("./use-dto.decorator"), exports);
 __exportStar(require("./validator.decorators"), exports);
 __exportStar(require("./controller.decorator"), exports);
+__exportStar(require("./api-paginated-response.decorator"), exports);
+__exportStar(require("./paginated-response.decorator"), exports);

package/decorators/paginated-response.decorator.d.ts

@@ -0,0 +1,11 @@
+export declare function createPaginatedResponseDto<T extends new (...args: any[]) => any>(entityClass: T): {
+    new (): {
+        data: InstanceType<T>[];
+        count?: number;
+        total?: number;
+        page?: number;
+        pageCount?: number;
+        hasPreviousPage?: boolean;
+        hasNextPage?: boolean;
+    };
+};

package/decorators/paginated-response.decorator.js

@@ -0,0 +1,60 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPaginatedResponseDto = createPaginatedResponseDto;
+const swagger_1 = require("@nestjs/swagger");
+const class_transformer_1 = require("class-transformer");
+function createPaginatedResponseDto(entityClass) {
+    const entityName = entityClass.name.replace('Dto', '');
+    class PaginatedResponse {
+    }
+    __decorate([
+        (0, swagger_1.ApiProperty)({
+            type: entityClass,
+            isArray: true,
+            description: `${entityName} data`,
+        }),
+        (0, class_transformer_1.Type)(() => entityClass),
+        __metadata("design:type", Array)
+    ], PaginatedResponse.prototype, "data", void 0);
+    __decorate([
+        (0, swagger_1.ApiPropertyOptional)({
+            example: 10,
+            description: 'Number of items in current page',
+        }),
+        __metadata("design:type", Number)
+    ], PaginatedResponse.prototype, "count", void 0);
+    __decorate([
+        (0, swagger_1.ApiPropertyOptional)({ example: 100, description: 'Total number of items' }),
+        __metadata("design:type", Number)
+    ], PaginatedResponse.prototype, "total", void 0);
+    __decorate([
+        (0, swagger_1.ApiPropertyOptional)({ example: 1, description: 'Current page number' }),
+        __metadata("design:type", Number)
+    ], PaginatedResponse.prototype, "page", void 0);
+    __decorate([
+        (0, swagger_1.ApiPropertyOptional)({ example: 10, description: 'Total number of pages' }),
+        __metadata("design:type", Number)
+    ], PaginatedResponse.prototype, "pageCount", void 0);
+    __decorate([
+        (0, swagger_1.ApiPropertyOptional)({ example: false, description: 'Has previous page' }),
+        __metadata("design:type", Boolean)
+    ], PaginatedResponse.prototype, "hasPreviousPage", void 0);
+    __decorate([
+        (0, swagger_1.ApiPropertyOptional)({ example: true, description: 'Has next page' }),
+        __metadata("design:type", Boolean)
+    ], PaginatedResponse.prototype, "hasNextPage", void 0);
+    Object.defineProperty(PaginatedResponse, 'name', {
+        value: `${entityName}PaginatedResponseDto`,
+        writable: false,
+    });
+    return PaginatedResponse;
+}

package/decorators/use-dto.decorator.d.ts

@@ -2,4 +2,3 @@ import type { AbstractEntity } from '../common/abstract.entity';
 import type { AbstractDto } from '../common/dto/abstract.dto';
 import type { Constructor } from '../common/types';
 export declare function UseDto(dtoClass: Constructor<AbstractDto, [AbstractEntity, unknown]>): ClassDecorator;
-export declare function UseDto<Entity, Dto extends AbstractDto>(dtoClass: Constructor<Dto, [Entity, unknown?]>): ClassDecorator;

package/decorators/use-dto.decorator.js

@@ -4,15 +4,5 @@ exports.UseDto = UseDto;
 function UseDto(dtoClass) {
     return (ctor) => {
         ctor.prototype.dtoClass = dtoClass;
-        ctor.dtoClass = dtoClass;
-        if (!ctor.prototype.toDto) {
-            ctor.prototype.toDto = function (options) {
-                const DtoClass = this.constructor.dtoClass || dtoClass;
-                if (!DtoClass) {
-                    throw new Error(`You need to use @UseDto on class (${this.constructor.name}) be able to call toDto function`);
-                }
-                return new DtoClass(this, options);
-            };
-        }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "3.1.1-20",
+  "version": "3.1.1-22",
   "description": "A comprehensive NestJS framework for building enterprise-grade applications with best practices",
   "main": "index.js",
   "types": "index.d.ts",

package/setup/bootstrap.setup.js

@@ -118,6 +118,7 @@ const nestjs_cls_1 = require("nestjs-cls");
 const class_validator_1 = require("class-validator");
 const setup_1 = require("@sentry/nestjs/setup");
 const vault_1 = require("../vault");
+const dto_1 = require("../common/dto");
 function bootstrapSetup(AppModule, SetupSwagger) {
     return __awaiter(this, void 0, void 0, function* () {
         yield vault_1.VaultConfigLoader.loadVaultConfig();
@@ -126,7 +127,9 @@ function bootstrapSetup(AppModule, SetupSwagger) {
             bufferLogs: true,
             autoFlushLogs: true,
         });
-        (0, class_validator_1.useContainer)(app.select(AppModule), { fallbackOnErrors: true });
+        const appModuleRef = app.select(AppModule);
+        (0, class_validator_1.useContainer)(appModuleRef, { fallbackOnErrors: true });
+        dto_1.DtoContainer.useContainer(appModuleRef);
         const configService = app.select(__1.ServiceRegistryModule).get(__1.ApiConfigService);
         const logger = app.get(nestjs_pino_1.Logger);
         app.useLogger(logger);
@@ -136,7 +139,9 @@ function bootstrapSetup(AppModule, SetupSwagger) {
         app.enableShutdownHooks();
         app.enableVersioning();
         app.enable('trust proxy');
-        app.use(bodyParse.json({ limit: '50mb' }), new nestjs_cls_1.ClsMiddleware({}).use, (0, __1.RequestIdMiddleware)(), (0, __1.PowerByMiddleware)(), (0, __1.OmniAuthMiddleware)(), compression());
+        app.use(bodyParse.json({ limit: '50mb' }), new nestjs_cls_1.ClsMiddleware({
+            saveReq: true,
+        }).use, (0, __1.RequestIdMiddleware)(), (0, __1.PowerByMiddleware)(), (0, __1.OmniAuthMiddleware)(), compression());
         const reflector = app.get(core_1.Reflector);
         app.useGlobalFilters(new setup_1.SentryGlobalFilter(), new __1.HttpExceptionFilter(), new __1.QueryFailedFilter(reflector));
         app.useGlobalInterceptors(new __1.LanguageInterceptor(), new __1.TranslationInterceptor(), new nestjs_pino_1.LoggerErrorInterceptor());

package/shared/serviceRegistryModule.js

@@ -58,7 +58,7 @@ const modules = [
     }),
     nestjs_cls_1.ClsModule.forRoot({
         global: true,
-        middleware: { mount: true },
+        middleware: { mount: true, saveReq: true },
         plugins: [
             new transactional_1.ClsPluginTransactional({
                 imports: [typeorm_1.TypeOrmModule],