@flusys/nestjs-shared 7.0.2 → 8.0.0-beta.1

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

@@ -1,459 +0,0 @@
-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'
-            }));
-        });
-    });
-});
-export { };

package/fesm/modules/cache/cache.module.js

@@ -1,29 +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;
-}
-import { HybridCache } from '../../classes/hybrid-cache.class';
-import { CACHE_INSTANCE } from '../../constants';
-import { Module } from '@nestjs/common';
-export class CacheModule {
-    static forRoot(isGlobal = true, memoryTtl = 60_000, memorySize = 5000) {
-        return {
-            module: CacheModule,
-            global: isGlobal,
-            providers: [
-                {
-                    provide: CACHE_INSTANCE,
-                    useFactory: ()=>new HybridCache(memoryTtl, memorySize)
-                }
-            ],
-            exports: [
-                CACHE_INSTANCE
-            ]
-        };
-    }
-}
-CacheModule = _ts_decorate([
-    Module({})
-], CacheModule);

package/fesm/modules/cache/cache.module.spec.js

@@ -1,44 +0,0 @@
-const mockHybridCacheCtor = jest.fn();
-jest.mock('../../classes/hybrid-cache.class', ()=>({
-        HybridCache: class {
-            constructor(...args){
-                mockHybridCacheCtor(...args);
-            }
-        }
-    }));
-import { CacheModule } from './cache.module';
-import { CACHE_INSTANCE } from '../../constants';
-describe('CacheModule', ()=>{
-    beforeEach(()=>{
-        mockHybridCacheCtor.mockClear();
-    });
-    it('should default to a global module when isGlobal is not specified', ()=>{
-        const dynamicModule = CacheModule.forRoot();
-        expect(dynamicModule.module).toBe(CacheModule);
-        expect(dynamicModule.global).toBe(true);
-    });
-    it('should respect isGlobal=false', ()=>{
-        const dynamicModule = CacheModule.forRoot(false);
-        expect(dynamicModule.global).toBe(false);
-    });
-    it('should provide and export CACHE_INSTANCE', ()=>{
-        const dynamicModule = CacheModule.forRoot();
-        expect(dynamicModule.exports).toEqual([
-            CACHE_INSTANCE
-        ]);
-        expect(dynamicModule.providers).toHaveLength(1);
-        expect(dynamicModule.providers[0].provide).toBe(CACHE_INSTANCE);
-    });
-    it('should build the HybridCache with default ttl/size when the factory runs with no args', ()=>{
-        const dynamicModule = CacheModule.forRoot();
-        const factory = dynamicModule.providers[0].useFactory;
-        factory();
-        expect(mockHybridCacheCtor).toHaveBeenCalledWith(60_000, 5000);
-    });
-    it('should forward custom memoryTtl and memorySize to the HybridCache factory', ()=>{
-        const dynamicModule = CacheModule.forRoot(true, 30_000, 1000);
-        const factory = dynamicModule.providers[0].useFactory;
-        factory();
-        expect(mockHybridCacheCtor).toHaveBeenCalledWith(30_000, 1000);
-    });
-});

package/fesm/modules/datasource/index.js

@@ -1 +0,0 @@
-export * from './multi-tenant-datasource.service';