@flusys/nestjs-shared 7.1.0 → 8.0.0

package/fesm/decorators/api-response.decorator.spec.js

@@ -1,122 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(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;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-import 'reflect-metadata';
-import { SingleResponseDto, ListResponseDto, BulkResponseDto } from '../dtos';
-import { ApiResponseDto } from './api-response.decorator';
-// @nestjs/swagger doesn't expose ./dist/constants via its package "exports" map,
-// so the decorator metadata keys are mirrored here (see node_modules/@nestjs/swagger/dist/constants.js).
-const SWAGGER_API_RESPONSE = 'swagger/apiResponse';
-const SWAGGER_API_EXTRA_MODELS = 'swagger/apiExtraModels';
-let SampleDto = class SampleDto {
-    constructor(){
-        _define_property(this, "id", void 0);
-    }
-};
-function getApiResponseSchema(target, methodName) {
-    const responses = Reflect.getMetadata(SWAGGER_API_RESPONSE, target[methodName]);
-    // ApiOkResponse stores under status code 200
-    return responses?.[200]?.schema ?? responses?.['200']?.schema;
-}
-describe('ApiResponseDto', ()=>{
-    it('should wrap a single response in SingleResponseDto by default', ()=>{
-        let Controller = class Controller {
-            handler() {}
-        };
-        _ts_decorate([
-            ApiResponseDto(SampleDto),
-            _ts_metadata("design:type", Function),
-            _ts_metadata("design:paramtypes", []),
-            _ts_metadata("design:returntype", void 0)
-        ], Controller.prototype, "handler", null);
-        const schema = getApiResponseSchema(Controller.prototype, 'handler');
-        expect(schema.allOf[0].$ref).toContain(SingleResponseDto.name);
-        expect(schema.allOf[1].properties.data.$ref).toContain(SampleDto.name);
-        expect(schema.allOf[1].properties.meta).toBeUndefined();
-    });
-    it('should wrap a list response with pagination meta when isArray + list', ()=>{
-        let Controller = class Controller {
-            handler() {}
-        };
-        _ts_decorate([
-            ApiResponseDto(SampleDto, true, 'list'),
-            _ts_metadata("design:type", Function),
-            _ts_metadata("design:paramtypes", []),
-            _ts_metadata("design:returntype", void 0)
-        ], Controller.prototype, "handler", null);
-        const schema = getApiResponseSchema(Controller.prototype, 'handler');
-        expect(schema.allOf[0].$ref).toContain(ListResponseDto.name);
-        expect(schema.allOf[1].properties.data.type).toBe('array');
-        expect(schema.allOf[1].properties.data.items.$ref).toContain(SampleDto.name);
-        expect(schema.allOf[1].properties.meta.$ref).toBeDefined();
-    });
-    it('should wrap a bulk response with bulk meta when isArray + bulk', ()=>{
-        let Controller = class Controller {
-            handler() {}
-        };
-        _ts_decorate([
-            ApiResponseDto(SampleDto, true, 'bulk'),
-            _ts_metadata("design:type", Function),
-            _ts_metadata("design:paramtypes", []),
-            _ts_metadata("design:returntype", void 0)
-        ], Controller.prototype, "handler", null);
-        const schema = getApiResponseSchema(Controller.prototype, 'handler');
-        expect(schema.allOf[0].$ref).toContain(BulkResponseDto.name);
-        expect(schema.allOf[1].properties.data.type).toBe('array');
-        expect(schema.allOf[1].properties.meta.$ref).toBeDefined();
-    });
-    it('should use SingleResponseDto when isArray is true but arrayType is "single"', ()=>{
-        let Controller = class Controller {
-            handler() {}
-        };
-        _ts_decorate([
-            ApiResponseDto(SampleDto, true, 'single'),
-            _ts_metadata("design:type", Function),
-            _ts_metadata("design:paramtypes", []),
-            _ts_metadata("design:returntype", void 0)
-        ], Controller.prototype, "handler", null);
-        const schema = getApiResponseSchema(Controller.prototype, 'handler');
-        expect(schema.allOf[0].$ref).toContain(SingleResponseDto.name);
-        // NOTE: data schema stays array-shaped here because `isArray` (not `arrayType`) drives it —
-        // arrayType only controls which wrapper/meta DTO is chosen.
-        expect(schema.allOf[1].properties.data.type).toBe('array');
-        expect(schema.allOf[1].properties.data.items.$ref).toContain(SampleDto.name);
-    });
-    it('should register extra models including the wrapper DTOs and the given DTO', ()=>{
-        let Controller = class Controller {
-            handler() {}
-        };
-        _ts_decorate([
-            ApiResponseDto(SampleDto),
-            _ts_metadata("design:type", Function),
-            _ts_metadata("design:paramtypes", []),
-            _ts_metadata("design:returntype", void 0)
-        ], Controller.prototype, "handler", null);
-        const extraModels = Reflect.getMetadata(SWAGGER_API_EXTRA_MODELS, Controller.prototype.handler);
-        expect(extraModels).toEqual(expect.arrayContaining([
-            SingleResponseDto,
-            ListResponseDto,
-            BulkResponseDto,
-            SampleDto
-        ]));
-    });
-});

package/fesm/decorators/current-user.decorator.js

@@ -1,18 +0,0 @@
-import { createParamDecorator } from '@nestjs/common';
-/**
- * Parameter decorator that extracts the current user from the request.
- * Works with any authentication guard that sets request.user
- *
- * @example
- * // Get entire user object
- * @Get('profile')
- * getProfile(@CurrentUser() user: User) { }
- *
- * // Get specific property
- * @Get('id')
- * getId(@CurrentUser('id') userId: string) { }
- */ export const CurrentUser = createParamDecorator((data, ctx)=>{
-    const request = ctx.switchToHttp().getRequest();
-    const user = request.user;
-    return data ? user?.[data] : user;
-});

package/fesm/decorators/current-user.decorator.spec.js

@@ -1,73 +0,0 @@
-function _ts_decorate(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;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-// createParamDecorator wraps the factory; the underlying factory is invoked via
-// the ROUTE_ARGS_METADATA internals. We extract it directly to unit-test the logic
-// without mounting a full controller/route.
-import { CurrentUser } from './current-user.decorator';
-function getParamDecoratorFactory(decorator) {
-    let Test = class Test {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        test(_value) {
-        /* noop */ }
-    };
-    _ts_decorate([
-        _ts_param(0, decorator()),
-        _ts_metadata("design:type", Function),
-        _ts_metadata("design:paramtypes", [
-            Object
-        ]),
-        _ts_metadata("design:returntype", void 0)
-    ], Test.prototype, "test", null);
-    const args = Reflect.getMetadata('__routeArguments__', Test, 'test');
-    const [firstParam] = Object.values(args);
-    return firstParam.factory;
-}
-function buildContext(request) {
-    return {
-        switchToHttp: ()=>({
-                getRequest: ()=>request
-            })
-    };
-}
-describe('CurrentUser', ()=>{
-    const factory = getParamDecoratorFactory(CurrentUser);
-    it('should return the entire user object when called without data', ()=>{
-        const user = buildMockUser();
-        const ctx = buildContext({
-            user
-        });
-        expect(factory(undefined, ctx)).toBe(user);
-    });
-    it('should return a specific property when data is provided', ()=>{
-        const user = buildMockUser({
-            email: 'specific@example.com'
-        });
-        const ctx = buildContext({
-            user
-        });
-        expect(factory('email', ctx)).toBe('specific@example.com');
-    });
-    it('should return undefined when requesting a property from a null user', ()=>{
-        const ctx = buildContext({
-            user: null
-        });
-        expect(factory('email', ctx)).toBeUndefined();
-    });
-    it('should return undefined for the whole user when request.user is undefined', ()=>{
-        const ctx = buildContext({});
-        expect(factory(undefined, ctx)).toBeUndefined();
-    });
-});

package/fesm/decorators/log-action.decorator.js

@@ -1,139 +0,0 @@
-import { Logger } from '@nestjs/common';
-import { createModuleLogger } from '../classes/winston.logger.class';
-import { getRequestId, getUserId, getTenantId, getCompanyId } from '../middlewares/logger.middleware';
-function createLoggerAdapter(className, moduleName) {
-    if (moduleName) {
-        const winstonLogger = createModuleLogger(moduleName);
-        return {
-            log: (level, message, meta)=>{
-                winstonLogger.log(level, message, {
-                    context: className,
-                    ...meta
-                });
-            },
-            error: (message, stack, meta)=>{
-                winstonLogger.error(message, {
-                    context: className,
-                    stack,
-                    ...meta
-                });
-            }
-        };
-    }
-    const nestLogger = new Logger(className);
-    return {
-        log: (level, message, meta)=>{
-            nestLogger[level](message, meta);
-        },
-        error: (message, stack, meta)=>{
-            nestLogger.error(message, stack, meta);
-        }
-    };
-}
-export function LogAction(options = {}) {
-    return function(target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        const className = target.constructor.name;
-        const methodName = String(propertyKey);
-        descriptor.value = async function(...args) {
-            const startTime = Date.now();
-            // Resolve module: decorator option > instance property > undefined
-            const moduleName = options.module || this.moduleName;
-            const logger = createLoggerAdapter(className, moduleName);
-            const action = options.action || `${this.entityName || className}.${methodName}`;
-            const logLevel = options.logLevel || 'debug';
-            const context = {
-                requestId: getRequestId(),
-                userId: getUserId(),
-                tenantId: getTenantId(),
-                companyId: getCompanyId(),
-                method: methodName,
-                module: moduleName
-            };
-            const startMessage = `Executing action method "${action}"`;
-            const startContext = options.includeParams ? {
-                ...context,
-                params: sanitizeParams(args)
-            } : context;
-            logger.log(logLevel, startMessage, startContext);
-            try {
-                const result = await originalMethod.apply(this, args);
-                const duration = Date.now() - startTime;
-                const resultType = getResultType(result);
-                const successMessage = `Executed action method "${action}", returned result "${resultType}" in ${duration.toFixed(2)}ms.`;
-                const successContext = options.includeResult && result ? {
-                    ...context,
-                    duration: `${duration}ms`,
-                    resultType,
-                    resultPreview: getResultPreview(result)
-                } : {
-                    ...context,
-                    duration: `${duration}ms`,
-                    resultType
-                };
-                logger.log(logLevel, successMessage, successContext);
-                return result;
-            } catch (error) {
-                const duration = Date.now() - startTime;
-                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                logger.error(`Failed action method "${action}" after ${duration.toFixed(2)}ms: ${errorMessage}`, error instanceof Error ? error.stack : undefined, {
-                    ...context,
-                    duration: `${duration}ms`,
-                    error: errorMessage
-                });
-                throw error;
-            }
-        };
-        return descriptor;
-    };
-}
-function sanitizeParams(args) {
-    return args.map((arg)=>{
-        if (arg === null || arg === undefined) return arg;
-        if (typeof arg === 'object') {
-            const sanitized = {
-                ...arg
-            };
-            const sensitiveKeys = [
-                'password',
-                'secret',
-                'token',
-                'apiKey',
-                'authorization'
-            ];
-            for (const key of Object.keys(sanitized)){
-                if (sensitiveKeys.some((sk)=>key.toLowerCase().includes(sk))) {
-                    sanitized[key] = '[REDACTED]';
-                }
-            }
-            return sanitized;
-        }
-        return arg;
-    });
-}
-function getResultType(result) {
-    if (result === null) return 'null';
-    if (result === undefined) return 'undefined';
-    if (Array.isArray(result)) return `Array<${result.length} items>`;
-    if (typeof result === 'object') {
-        const name = result.constructor?.name;
-        return name && name !== 'Object' ? name : 'Object';
-    }
-    return typeof result;
-}
-function getResultPreview(result) {
-    if (Array.isArray(result)) {
-        return {
-            count: result.length,
-            sample: result.slice(0, 2)
-        };
-    }
-    if (typeof result === 'object' && result !== null) {
-        const keys = Object.keys(result).slice(0, 5);
-        return {
-            keys,
-            hasMore: Object.keys(result).length > 5
-        };
-    }
-    return result;
-}