@flusys/nestjs-shared 6.0.2 → 6.1.1

package/cjs/interceptors/set-user-field-on-body.interceptor.spec.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _rxjs = require("rxjs");
+const _setuserfieldonbodyinterceptor = require("./set-user-field-on-body.interceptor");
+function buildContext(body, user) {
+    const request = {
+        body,
+        user
+    };
+    const context = {
+        switchToHttp: ()=>({
+                getRequest: ()=>request
+            })
+    };
+    return {
+        context,
+        request
+    };
+}
+function buildCallHandler() {
+    return {
+        handle: jest.fn().mockReturnValue((0, _rxjs.of)('next-result'))
+    };
+}
+describe('createSetUserFieldInterceptor', ()=>{
+    it('should set the field on a single object body from the authenticated user', ()=>{
+        const Interceptor = (0, _setuserfieldonbodyinterceptor.createSetUserFieldInterceptor)('createdById');
+        const interceptor = new Interceptor();
+        const { context, request } = buildContext({
+            name: 'Product'
+        }, {
+            id: 'user-1'
+        });
+        interceptor.intercept(context, buildCallHandler());
+        expect(request.body).toEqual({
+            name: 'Product',
+            createdById: 'user-1'
+        });
+    });
+    it('should set the field on every item of an array body', ()=>{
+        const Interceptor = (0, _setuserfieldonbodyinterceptor.createSetUserFieldInterceptor)('updatedById');
+        const interceptor = new Interceptor();
+        const { context, request } = buildContext([
+            {
+                name: 'A'
+            },
+            {
+                name: 'B'
+            }
+        ], {
+            id: 'user-2'
+        });
+        interceptor.intercept(context, buildCallHandler());
+        expect(request.body).toEqual([
+            {
+                name: 'A',
+                updatedById: 'user-2'
+            },
+            {
+                name: 'B',
+                updatedById: 'user-2'
+            }
+        ]);
+    });
+    it('should not modify the body when there is no authenticated user', ()=>{
+        const Interceptor = (0, _setuserfieldonbodyinterceptor.createSetUserFieldInterceptor)('deletedById');
+        const interceptor = new Interceptor();
+        const { context, request } = buildContext({
+            name: 'Product'
+        }, undefined);
+        interceptor.intercept(context, buildCallHandler());
+        expect(request.body).toEqual({
+            name: 'Product'
+        });
+    });
+    it('should not throw when body is null and there is no user', ()=>{
+        const Interceptor = (0, _setuserfieldonbodyinterceptor.createSetUserFieldInterceptor)('createdById');
+        const interceptor = new Interceptor();
+        const { context, request } = buildContext(null, undefined);
+        expect(()=>interceptor.intercept(context, buildCallHandler())).not.toThrow();
+        expect(request.body).toBeNull();
+    });
+    it('should return next.handle() observable', (done)=>{
+        const Interceptor = (0, _setuserfieldonbodyinterceptor.createSetUserFieldInterceptor)('createdById');
+        const interceptor = new Interceptor();
+        const { context } = buildContext({}, {
+            id: 'user-1'
+        });
+        interceptor.intercept(context, buildCallHandler()).subscribe((value)=>{
+            expect(value).toBe('next-result');
+            done();
+        });
+    });
+});
+describe('preconfigured user-field interceptors', ()=>{
+    it('should set createdById via SetCreatedByOnBody', ()=>{
+        const interceptor = new _setuserfieldonbodyinterceptor.SetCreatedByOnBody();
+        const { context, request } = buildContext({}, {
+            id: 'user-1'
+        });
+        interceptor.intercept(context, buildCallHandler());
+        expect(request.body).toEqual({
+            createdById: 'user-1'
+        });
+    });
+    it('should set updatedById via SetUpdateByOnBody', ()=>{
+        const interceptor = new _setuserfieldonbodyinterceptor.SetUpdateByOnBody();
+        const { context, request } = buildContext({}, {
+            id: 'user-1'
+        });
+        interceptor.intercept(context, buildCallHandler());
+        expect(request.body).toEqual({
+            updatedById: 'user-1'
+        });
+    });
+    it('should set deletedById via SetDeletedByOnBody', ()=>{
+        const interceptor = new _setuserfieldonbodyinterceptor.SetDeletedByOnBody();
+        const { context, request } = buildContext({}, {
+            id: 'user-1'
+        });
+        interceptor.intercept(context, buildCallHandler());
+        expect(request.body).toEqual({
+            deletedById: 'user-1'
+        });
+    });
+});

package/cjs/interceptors/slug.interceptor.spec.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _rxjs = require("rxjs");
+const _sluginterceptor = require("./slug.interceptor");
+function buildContext(body) {
+    const request = {
+        body
+    };
+    const context = {
+        switchToHttp: ()=>({
+                getRequest: ()=>request
+            })
+    };
+    return {
+        context,
+        request
+    };
+}
+function buildCallHandler() {
+    return {
+        handle: jest.fn().mockReturnValue((0, _rxjs.of)('next-result'))
+    };
+}
+describe('Slug interceptor', ()=>{
+    let utilsService;
+    let interceptor;
+    beforeEach(()=>{
+        utilsService = {
+            transformToSlug: jest.fn((value)=>value.toLowerCase().replace(/\s+/g, '-'))
+        };
+        interceptor = new _sluginterceptor.Slug(utilsService);
+    });
+    it('should generate a slug from name on a single object body without one', ()=>{
+        const { context, request } = buildContext({
+            name: 'My Product'
+        });
+        interceptor.intercept(context, buildCallHandler());
+        expect(utilsService.transformToSlug).toHaveBeenCalledWith('My Product');
+        expect(request.body).toEqual({
+            name: 'My Product',
+            slug: 'my-product'
+        });
+    });
+    it('should not overwrite an existing slug on a single object body', ()=>{
+        const { context, request } = buildContext({
+            name: 'My Product',
+            slug: 'custom-slug'
+        });
+        interceptor.intercept(context, buildCallHandler());
+        expect(utilsService.transformToSlug).not.toHaveBeenCalled();
+        expect(request.body).toEqual({
+            name: 'My Product',
+            slug: 'custom-slug'
+        });
+    });
+    it('should not generate a slug when there is no name', ()=>{
+        const { context, request } = buildContext({
+            description: 'no name here'
+        });
+        interceptor.intercept(context, buildCallHandler());
+        expect(utilsService.transformToSlug).not.toHaveBeenCalled();
+        expect(request.body).toEqual({
+            description: 'no name here'
+        });
+    });
+    it('should generate slugs for each array item missing one', ()=>{
+        const { context, request } = buildContext([
+            {
+                name: 'Item One'
+            },
+            {
+                name: 'Item Two',
+                slug: 'existing'
+            },
+            {
+                description: 'no name'
+            }
+        ]);
+        interceptor.intercept(context, buildCallHandler());
+        expect(request.body).toEqual([
+            {
+                name: 'Item One',
+                slug: 'item-one'
+            },
+            {
+                name: 'Item Two',
+                slug: 'existing'
+            },
+            {
+                description: 'no name'
+            }
+        ]);
+    });
+    it('should not throw when body is undefined', ()=>{
+        const { context, request } = buildContext(undefined);
+        expect(()=>interceptor.intercept(context, buildCallHandler())).not.toThrow();
+        expect(request.body).toBeUndefined();
+    });
+    it('should return next.handle() observable', (done)=>{
+        const { context } = buildContext({
+            name: 'X'
+        });
+        interceptor.intercept(context, buildCallHandler()).subscribe((value)=>{
+            expect(value).toBe('next-result');
+            done();
+        });
+    });
+});

package/cjs/middlewares/logger.middleware.spec.js

@@ -0,0 +1,462 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const mockGetLogConfig = jest.fn();
+jest.mock('@flusys/nestjs-core/config', ()=>({
+        envConfig: {
+            getLogConfig: (...args)=>mockGetLogConfig(...args)
+        }
+    }));
+const mockLoggerInfo = jest.fn();
+const mockLoggerWarn = jest.fn();
+const mockLoggerError = jest.fn();
+const mockLoggerLog = jest.fn();
+jest.mock('../classes/winston.logger.class', ()=>({
+        instance: {
+            info: (...args)=>mockLoggerInfo(...args),
+            warn: (...args)=>mockLoggerWarn(...args),
+            error: (...args)=>mockLoggerError(...args),
+            log: (...args)=>mockLoggerLog(...args)
+        }
+    }));
+let uuidCounter = 0;
+jest.mock('uuid', ()=>({
+        v4: ()=>`generated-uuid-${++uuidCounter}`
+    }));
+function loadMiddleware(logConfig) {
+    jest.resetModules();
+    jest.clearAllMocks();
+    uuidCounter = 0;
+    mockGetLogConfig.mockReturnValue({
+        dir: 'logs',
+        level: 'info',
+        maxSize: '20m',
+        maxFiles: '14d',
+        disableHttpLogging: false,
+        ...logConfig
+    });
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require('./logger.middleware');
+}
+function makeReqRes(overrides = {}) {
+    const req = {
+        headers: {},
+        method: 'GET',
+        originalUrl: '/api/users',
+        path: '/api/users',
+        query: {},
+        body: undefined,
+        socket: {
+            remoteAddress: '10.0.0.1'
+        },
+        ...overrides
+    };
+    const res = {
+        statusCode: 200,
+        statusMessage: 'OK',
+        setHeader: jest.fn(),
+        getHeader: jest.fn().mockReturnValue(undefined),
+        send: jest.fn(function(body) {
+            return body;
+        }),
+        json: jest.fn(function(body) {
+            return body;
+        }),
+        end: jest.fn(function() {
+            return this;
+        }),
+        on: jest.fn()
+    };
+    return {
+        req,
+        res
+    };
+}
+describe('LoggerMiddleware', ()=>{
+    describe('request correlation', ()=>{
+        it('should generate a request id when none is provided and echo it back on the response', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            const next = jest.fn();
+            middleware.use(req, res, next);
+            expect(res.setHeader).toHaveBeenCalledWith('x-request-id', 'generated-uuid-1');
+            expect(next).toHaveBeenCalledTimes(1);
+        });
+        it('should reuse an incoming x-request-id header instead of generating one', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes({
+                headers: {
+                    'x-request-id': 'incoming-id'
+                }
+            });
+            const next = jest.fn();
+            middleware.use(req, res, next);
+            expect(res.setHeader).toHaveBeenCalledWith('x-request-id', 'incoming-id');
+        });
+        it('should expose requestId/tenantId via context accessors inside the request scope', ()=>{
+            const mod = loadMiddleware({});
+            const middleware = new mod.LoggerMiddleware();
+            const { req, res } = makeReqRes({
+                headers: {
+                    'x-request-id': 'req-1',
+                    'x-tenant-id': 'tenant-1'
+                }
+            });
+            let seenDuringRequest;
+            const next = jest.fn(()=>{
+                seenDuringRequest = {
+                    requestId: mod.getRequestId(),
+                    tenantId: mod.getTenantId()
+                };
+            });
+            middleware.use(req, res, next);
+            expect(seenDuringRequest).toEqual({
+                requestId: 'req-1',
+                tenantId: 'tenant-1'
+            });
+            // outside the request scope the store is gone
+            expect(mod.getRequestId()).toBeUndefined();
+            expect(mod.getTenantId()).toBeUndefined();
+        });
+        it('should leave tenantId undefined when no x-tenant-id header is present', ()=>{
+            const mod = loadMiddleware({});
+            const middleware = new mod.LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            let tenantIdSeen;
+            const next = jest.fn(()=>{
+                tenantIdSeen = mod.getTenantId();
+            });
+            middleware.use(req, res, next);
+            expect(tenantIdSeen).toBeUndefined();
+        });
+        it('getUserId/getCompanyId should return undefined when not explicitly set on the context', ()=>{
+            const mod = loadMiddleware({});
+            const middleware = new mod.LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            let seen;
+            const next = jest.fn(()=>{
+                seen = {
+                    userId: mod.getUserId(),
+                    companyId: mod.getCompanyId()
+                };
+            });
+            middleware.use(req, res, next);
+            expect(seen).toEqual({
+                userId: undefined,
+                companyId: undefined
+            });
+        });
+    });
+    describe('excluded / disabled logging', ()=>{
+        it.each([
+            '/health',
+            '/metrics',
+            '/favicon.ico'
+        ])('should skip request logging for excluded path %s', (path)=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes({
+                originalUrl: path,
+                path
+            });
+            const next = jest.fn();
+            middleware.use(req, res, next);
+            expect(mockLoggerInfo).not.toHaveBeenCalled();
+            expect(next).toHaveBeenCalled();
+        });
+        it('should skip request logging entirely when DISABLE_HTTP_LOGGING is true', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({
+                disableHttpLogging: true
+            });
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            const next = jest.fn();
+            middleware.use(req, res, next);
+            expect(mockLoggerInfo).not.toHaveBeenCalled();
+            expect(next).toHaveBeenCalled();
+        });
+        it('should still set up request correlation even when logging is disabled', ()=>{
+            const mod = loadMiddleware({
+                disableHttpLogging: true
+            });
+            const middleware = new mod.LoggerMiddleware();
+            const { req, res } = makeReqRes({
+                headers: {
+                    'x-request-id': 'req-1'
+                }
+            });
+            let seen;
+            const next = jest.fn(()=>{
+                seen = mod.getRequestId();
+            });
+            middleware.use(req, res, next);
+            expect(seen).toBe('req-1');
+        });
+    });
+    describe('request logging', ()=>{
+        it('should log a descriptive start message with method/url/ip', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes({
+                method: 'POST',
+                originalUrl: '/api/orders'
+            });
+            middleware.use(req, res, jest.fn());
+            expect(mockLoggerInfo).toHaveBeenCalledWith(expect.stringContaining('Started processing request "POST" "/api/orders" from "10.0.0.1"'), expect.objectContaining({
+                context: 'HTTP',
+                method: 'POST',
+                url: '/api/orders'
+            }));
+        });
+        it('should prefer x-forwarded-for over the socket remote address', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes({
+                headers: {
+                    'x-forwarded-for': '203.0.113.5, 10.0.0.1'
+                }
+            });
+            middleware.use(req, res, jest.fn());
+            expect(mockLoggerInfo).toHaveBeenCalledWith(expect.stringContaining('from "203.0.113.5"'), expect.anything());
+        });
+        it('should fall back to "unknown" ip when neither header nor socket is available', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes({
+                socket: undefined
+            });
+            middleware.use(req, res, jest.fn());
+            expect(mockLoggerInfo).toHaveBeenCalledWith(expect.stringContaining('from "unknown"'), expect.anything());
+        });
+        it('should include the query object only when it has keys', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes({
+                query: {
+                    page: '1'
+                }
+            });
+            middleware.use(req, res, jest.fn());
+            expect(mockLoggerInfo).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                query: {
+                    page: '1'
+                }
+            }));
+        });
+        it('should omit the query field entirely for an empty query object', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes({
+                query: {}
+            });
+            middleware.use(req, res, jest.fn());
+            const logData = mockLoggerInfo.mock.calls[0][1];
+            expect(logData.query).toBeUndefined();
+        });
+        it('should not include a body summary when not in debug mode', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({
+                level: 'info'
+            });
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes({
+                body: {
+                    pagination: {
+                        currentPage: 2
+                    }
+                }
+            });
+            middleware.use(req, res, jest.fn());
+            const logData = mockLoggerInfo.mock.calls[0][1];
+            expect(logData.body).toBeUndefined();
+        });
+        it('should include a summarized body when in debug mode', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({
+                level: 'debug'
+            });
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes({
+                body: {
+                    pagination: {
+                        currentPage: 2,
+                        pageSize: 10
+                    },
+                    filter: {
+                        active: true
+                    },
+                    id: 'x-1'
+                }
+            });
+            middleware.use(req, res, jest.fn());
+            const logData = mockLoggerInfo.mock.calls[0][1];
+            expect(JSON.parse(logData.body)).toEqual({
+                page: 2,
+                pageSize: 10,
+                filterKeys: [
+                    'active'
+                ],
+                id: 'x-1'
+            });
+        });
+        it('should truncate an overly long non-object body in debug mode', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({
+                level: 'debug'
+            });
+            const middleware = new LoggerMiddleware();
+            const longBody = 'x'.repeat(1500);
+            const { req, res } = makeReqRes({
+                body: longBody
+            });
+            middleware.use(req, res, jest.fn());
+            const logData = mockLoggerInfo.mock.calls[0][1];
+            expect(logData.body.endsWith('...')).toBe(true);
+            expect(logData.body.length).toBe(1003);
+        });
+    });
+    describe('response logging', ()=>{
+        it('should log once even when send/json/end are all invoked for the same response', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            middleware.use(req, res, jest.fn());
+            mockLoggerLog.mockClear();
+            res.json({
+                success: true
+            });
+            res.send({
+                success: true
+            });
+            res.end();
+            expect(mockLoggerLog).toHaveBeenCalledTimes(1);
+        });
+        it('should log at "info" for 2xx responses', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            res.statusCode = 200;
+            middleware.use(req, res, jest.fn());
+            mockLoggerLog.mockClear();
+            res.json({
+                success: true
+            });
+            expect(mockLoggerLog).toHaveBeenCalledWith('info', expect.any(String), expect.any(Object));
+        });
+        it('should log at "warn" for 4xx responses and include a response body summary', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            res.statusCode = 404;
+            middleware.use(req, res, jest.fn());
+            mockLoggerLog.mockClear();
+            res.json({
+                success: false,
+                message: 'Not found'
+            });
+            expect(mockLoggerLog).toHaveBeenCalledWith('warn', expect.any(String), expect.objectContaining({
+                responseBody: expect.stringContaining('Not found')
+            }));
+        });
+        it('should log at "error" for 5xx responses', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            res.statusCode = 500;
+            middleware.use(req, res, jest.fn());
+            mockLoggerLog.mockClear();
+            res.json({
+                success: false
+            });
+            expect(mockLoggerLog).toHaveBeenCalledWith('error', expect.any(String), expect.any(Object));
+        });
+        it('should not include a response body summary for successful non-debug responses', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({
+                level: 'info'
+            });
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            res.statusCode = 200;
+            middleware.use(req, res, jest.fn());
+            mockLoggerLog.mockClear();
+            res.json({
+                success: true
+            });
+            const logData = mockLoggerLog.mock.calls[0][2];
+            expect(logData.responseBody).toBeUndefined();
+        });
+        it('should include a response body summary for successful responses in debug mode', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({
+                level: 'debug'
+            });
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            res.statusCode = 200;
+            middleware.use(req, res, jest.fn());
+            mockLoggerLog.mockClear();
+            res.json({
+                success: true,
+                data: [
+                    1,
+                    2,
+                    3
+                ]
+            });
+            const logData = mockLoggerLog.mock.calls[0][2];
+            expect(JSON.parse(logData.responseBody)).toEqual({
+                success: true,
+                dataCount: 3
+            });
+        });
+        it('should warn about slow requests over the 3s threshold on successful responses', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            res.statusCode = 200;
+            const realNow = Date.now;
+            let callCount = 0;
+            jest.spyOn(Date, 'now').mockImplementation(()=>{
+                callCount += 1;
+                // first call = startTime, subsequent calls happen after the "slow" work
+                return callCount === 1 ? 1_000 : 5_000;
+            });
+            middleware.use(req, res, jest.fn());
+            res.json({
+                success: true
+            });
+            expect(mockLoggerWarn).toHaveBeenCalledWith(expect.stringContaining('Slow request detected'), expect.objectContaining({
+                threshold: '3000ms'
+            }));
+            Date.now.mockRestore?.() ?? (Date.now = realNow);
+        });
+        it('should not warn about slow requests when the response was an error', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            res.statusCode = 500;
+            let callCount = 0;
+            jest.spyOn(Date, 'now').mockImplementation(()=>{
+                callCount += 1;
+                return callCount === 1 ? 1_000 : 5_000;
+            });
+            middleware.use(req, res, jest.fn());
+            res.json({
+                success: false
+            });
+            expect(mockLoggerWarn).not.toHaveBeenCalled();
+            Date.now.mockRestore();
+        });
+        it('should log response errors emitted on the res "error" event', ()=>{
+            const { LoggerMiddleware } = loadMiddleware({});
+            const middleware = new LoggerMiddleware();
+            const { req, res } = makeReqRes();
+            middleware.use(req, res, jest.fn());
+            const errorHandler = res.on.mock.calls.find(([event])=>event === 'error')?.[1];
+            expect(errorHandler).toBeDefined();
+            errorHandler(new Error('stream broke'));
+            expect(mockLoggerError).toHaveBeenCalledWith('Response error', expect.objectContaining({
+                error: 'stream broke'
+            }));
+        });
+    });
+});