@flusys/nestjs-shared 6.0.1 → 6.1.0

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

@@ -0,0 +1,122 @@
+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.spec.js

@@ -0,0 +1,73 @@
+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.spec.js

@@ -0,0 +1,349 @@
+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 { Logger } from '@nestjs/common';
+const mockWinstonLogger = {
+    log: jest.fn(),
+    error: jest.fn()
+};
+const createModuleLoggerMock = jest.fn((..._args)=>mockWinstonLogger);
+jest.mock('../classes/winston.logger.class', ()=>({
+        createModuleLogger: (...args)=>createModuleLoggerMock(...args)
+    }));
+const getRequestIdMock = jest.fn(()=>'req-1');
+const getUserIdMock = jest.fn(()=>'user-1');
+const getTenantIdMock = jest.fn(()=>'tenant-1');
+const getCompanyIdMock = jest.fn(()=>'company-1');
+jest.mock('../middlewares/logger.middleware', ()=>({
+        getRequestId: ()=>getRequestIdMock(),
+        getUserId: ()=>getUserIdMock(),
+        getTenantId: ()=>getTenantIdMock(),
+        getCompanyId: ()=>getCompanyIdMock()
+    }));
+import { LogAction } from './log-action.decorator';
+describe('LogAction', ()=>{
+    let nestLoggerWarnSpy;
+    let nestLoggerDebugSpy;
+    let nestLoggerErrorSpy;
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        nestLoggerWarnSpy = jest.spyOn(Logger.prototype, 'warn').mockImplementation(()=>undefined);
+        nestLoggerDebugSpy = jest.spyOn(Logger.prototype, 'debug').mockImplementation(()=>undefined);
+        nestLoggerErrorSpy = jest.spyOn(Logger.prototype, 'error').mockImplementation(()=>undefined);
+    });
+    afterEach(()=>{
+        jest.restoreAllMocks();
+    });
+    describe('using the Nest Logger (no moduleName)', ()=>{
+        let Service = class Service {
+            async doWork(value) {
+                return `done:${value}`;
+            }
+            async fail() {
+                throw new Error('boom');
+            }
+            constructor(){
+                _define_property(this, "entityName", 'product');
+            }
+        };
+        _ts_decorate([
+            LogAction(),
+            _ts_metadata("design:type", Function),
+            _ts_metadata("design:paramtypes", [
+                String
+            ]),
+            _ts_metadata("design:returntype", Promise)
+        ], Service.prototype, "doWork", null);
+        _ts_decorate([
+            LogAction(),
+            _ts_metadata("design:type", Function),
+            _ts_metadata("design:paramtypes", []),
+            _ts_metadata("design:returntype", Promise)
+        ], Service.prototype, "fail", null);
+        it('should log a debug start/success message and return the original result', async ()=>{
+            const service = new Service();
+            const result = await service.doWork('x');
+            expect(result).toBe('done:x');
+            expect(nestLoggerDebugSpy).toHaveBeenCalledTimes(2);
+            const [startMessage] = nestLoggerDebugSpy.mock.calls[0];
+            expect(startMessage).toContain('Executing action method "product.doWork"');
+            const [successMessage] = nestLoggerDebugSpy.mock.calls[1];
+            expect(successMessage).toContain('Executed action method "product.doWork"');
+        });
+        it('should log and rethrow the original error on failure', async ()=>{
+            const service = new Service();
+            await expect(service.fail()).rejects.toThrow('boom');
+            expect(nestLoggerErrorSpy).toHaveBeenCalledTimes(1);
+            const [message, stack] = nestLoggerErrorSpy.mock.calls[0];
+            expect(message).toContain('Failed action method "product.fail"');
+            expect(message).toContain('boom');
+            expect(stack).toEqual(expect.any(String));
+        });
+    });
+    describe('using the Winston module logger (moduleName resolved from instance property)', ()=>{
+        let Service = class Service {
+            async doWork() {
+                return {
+                    id: '1'
+                };
+            }
+            constructor(){
+                _define_property(this, "entityName", 'product');
+                _define_property(this, "moduleName", 'catalog');
+            }
+        };
+        _ts_decorate([
+            LogAction(),
+            _ts_metadata("design:type", Function),
+            _ts_metadata("design:paramtypes", []),
+            _ts_metadata("design:returntype", Promise)
+        ], Service.prototype, "doWork", null);
+        it('should resolve the module logger via createModuleLogger(moduleName)', async ()=>{
+            const service = new Service();
+            await service.doWork();
+            expect(createModuleLoggerMock).toHaveBeenCalledWith('catalog');
+            expect(mockWinstonLogger.log).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('options', ()=>{
+        it('should use a custom action name when provided', async ()=>{
+            let Service = class Service {
+                async doWork() {
+                    return 'ok';
+                }
+            };
+            _ts_decorate([
+                LogAction({
+                    action: 'custom.action'
+                }),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", Promise)
+            ], Service.prototype, "doWork", null);
+            await new Service().doWork();
+            const [startMessage] = nestLoggerDebugSpy.mock.calls[0];
+            expect(startMessage).toContain('"custom.action"');
+        });
+        it('should prefer decorator module option over instance moduleName', async ()=>{
+            let Service = class Service {
+                async doWork() {
+                    return 'ok';
+                }
+                constructor(){
+                    _define_property(this, "moduleName", 'instance-module');
+                }
+            };
+            _ts_decorate([
+                LogAction({
+                    module: 'decorator-module'
+                }),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", Promise)
+            ], Service.prototype, "doWork", null);
+            await new Service().doWork();
+            expect(createModuleLoggerMock).toHaveBeenCalledWith('decorator-module');
+        });
+        it('should use the custom logLevel', async ()=>{
+            let Service = class Service {
+                async doWork() {
+                    return 'ok';
+                }
+            };
+            _ts_decorate([
+                LogAction({
+                    logLevel: 'warn'
+                }),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", Promise)
+            ], Service.prototype, "doWork", null);
+            await new Service().doWork();
+            // logLevel routes to the matching Logger method (nestLogger.warn), not nestLogger.log
+            expect(nestLoggerWarnSpy).toHaveBeenCalledTimes(2);
+            expect(nestLoggerDebugSpy).not.toHaveBeenCalled();
+        });
+        it('should redact sensitive keys from params when includeParams is true', async ()=>{
+            let Service = class Service {
+                async doWork(_dto) {
+                    return 'ok';
+                }
+            };
+            _ts_decorate([
+                LogAction({
+                    includeParams: true
+                }),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", [
+                    typeof Record === "undefined" ? Object : Record
+                ]),
+                _ts_metadata("design:returntype", Promise)
+            ], Service.prototype, "doWork", null);
+            await new Service().doWork({
+                email: 'a@b.com',
+                password: 'secret',
+                token: 'abc'
+            });
+            const [, startContext] = nestLoggerDebugSpy.mock.calls[0];
+            expect(startContext.params[0]).toEqual({
+                email: 'a@b.com',
+                password: '[REDACTED]',
+                token: '[REDACTED]'
+            });
+        });
+        it('should pass through null/undefined/primitive args unchanged when sanitizing params', async ()=>{
+            let Service = class Service {
+                async doWork(_a, _b, _c) {
+                    return 'ok';
+                }
+            };
+            _ts_decorate([
+                LogAction({
+                    includeParams: true
+                }),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", [
+                    Object,
+                    Object,
+                    Object
+                ]),
+                _ts_metadata("design:returntype", Promise)
+            ], Service.prototype, "doWork", null);
+            await new Service().doWork(null, undefined, 'plain-string');
+            const [, startContext] = nestLoggerDebugSpy.mock.calls[0];
+            expect(startContext.params).toEqual([
+                null,
+                undefined,
+                'plain-string'
+            ]);
+        });
+        it('should include a result preview when includeResult is true and result is an array', async ()=>{
+            let Service = class Service {
+                async doWork() {
+                    return [
+                        1,
+                        2,
+                        3
+                    ];
+                }
+            };
+            _ts_decorate([
+                LogAction({
+                    includeResult: true
+                }),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", Promise)
+            ], Service.prototype, "doWork", null);
+            await new Service().doWork();
+            const [, successContext] = nestLoggerDebugSpy.mock.calls[1];
+            expect(successContext.resultType).toBe('Array<3 items>');
+            expect(successContext.resultPreview).toEqual({
+                count: 3,
+                sample: [
+                    1,
+                    2
+                ]
+            });
+        });
+        it('should include a keys-preview when includeResult is true and result is an object', async ()=>{
+            let Service = class Service {
+                async doWork() {
+                    return {
+                        a: 1,
+                        b: 2,
+                        c: 3,
+                        d: 4,
+                        e: 5,
+                        f: 6
+                    };
+                }
+            };
+            _ts_decorate([
+                LogAction({
+                    includeResult: true
+                }),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", Promise)
+            ], Service.prototype, "doWork", null);
+            await new Service().doWork();
+            const [, successContext] = nestLoggerDebugSpy.mock.calls[1];
+            expect(successContext.resultPreview).toEqual({
+                keys: [
+                    'a',
+                    'b',
+                    'c',
+                    'd',
+                    'e',
+                    'f'
+                ].slice(0, 5),
+                hasMore: true
+            });
+        });
+        it('should not attach a result preview when includeResult is false', async ()=>{
+            let Service = class Service {
+                async doWork() {
+                    return {
+                        a: 1
+                    };
+                }
+            };
+            _ts_decorate([
+                LogAction(),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", Promise)
+            ], Service.prototype, "doWork", null);
+            await new Service().doWork();
+            const [, successContext] = nestLoggerDebugSpy.mock.calls[1];
+            expect(successContext.resultPreview).toBeUndefined();
+        });
+        it('should report resultType "null" and "undefined" correctly', async ()=>{
+            let Service = class Service {
+                async returnsNull() {
+                    return null;
+                }
+                async returnsUndefined() {
+                    return undefined;
+                }
+            };
+            _ts_decorate([
+                LogAction(),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", Promise)
+            ], Service.prototype, "returnsNull", null);
+            _ts_decorate([
+                LogAction(),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", Promise)
+            ], Service.prototype, "returnsUndefined", null);
+            const service = new Service();
+            await service.returnsNull();
+            await service.returnsUndefined();
+            expect(nestLoggerDebugSpy.mock.calls[1][1].resultType).toBe('null');
+            expect(nestLoggerDebugSpy.mock.calls[3][1].resultType).toBe('undefined');
+        });
+    });
+});

package/fesm/decorators/public.decorator.spec.js

@@ -0,0 +1,46 @@
+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 { Reflector } from '@nestjs/core';
+import { IS_PUBLIC_KEY } from '../constants';
+import { Public } from './public.decorator';
+describe('Public', ()=>{
+    it('should set the IS_PUBLIC_KEY metadata to true on a method', ()=>{
+        let TestController = class TestController {
+            handler() {}
+        };
+        _ts_decorate([
+            Public(),
+            _ts_metadata("design:type", Function),
+            _ts_metadata("design:paramtypes", []),
+            _ts_metadata("design:returntype", void 0)
+        ], TestController.prototype, "handler", null);
+        const reflector = new Reflector();
+        const metadata = reflector.get(IS_PUBLIC_KEY, TestController.prototype.handler);
+        expect(metadata).toBe(true);
+    });
+    it('should set the IS_PUBLIC_KEY metadata to true on a class', ()=>{
+        let TestController = class TestController {
+        };
+        TestController = _ts_decorate([
+            Public()
+        ], TestController);
+        const reflector = new Reflector();
+        const metadata = reflector.get(IS_PUBLIC_KEY, TestController);
+        expect(metadata).toBe(true);
+    });
+    it('should not set metadata on a handler that does not use the decorator', ()=>{
+        let TestController = class TestController {
+            handler() {}
+        };
+        const reflector = new Reflector();
+        const metadata = reflector.get(IS_PUBLIC_KEY, TestController.prototype.handler);
+        expect(metadata).toBeUndefined();
+    });
+});