@nest-omni/core 3.1.1-19 → 3.1.1-21

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,63 @@
+"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,
+            meta: {
+                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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "3.1.1-19",
+  "version": "3.1.1-21",
   "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],