@flusys/nestjs-core 7.1.0 → 8.0.0

package/cjs/config/env-config.service.spec.js

@@ -1,325 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _envconfigservice = require("./env-config.service");
-describe('EnvConfigService', ()=>{
-    const ORIGINAL_ENV = {
-        ...process.env
-    };
-    afterEach(()=>{
-        for (const key of Object.keys(process.env)){
-            if (!(key in ORIGINAL_ENV)) delete process.env[key];
-        }
-        Object.assign(process.env, ORIGINAL_ENV);
-    });
-    describe('tryGetValue', ()=>{
-        it('should return env value for an unrestricted key', ()=>{
-            process.env.CUSTOM_KEY = 'custom-value';
-            expect(_envconfigservice.envConfig.tryGetValue('CUSTOM_KEY')).toBe('custom-value');
-        });
-        it('should return empty string when missing and throwOnMissing is false', ()=>{
-            delete process.env.MISSING_KEY;
-            expect(_envconfigservice.envConfig.tryGetValue('MISSING_KEY', false)).toBe('');
-        });
-        it('should throw when missing and throwOnMissing is true', ()=>{
-            delete process.env.MISSING_KEY;
-            expect(()=>_envconfigservice.envConfig.tryGetValue('MISSING_KEY', true)).toThrow('Config error - missing env.MISSING_KEY');
-        });
-        it.each([
-            [
-                'FRONTEND_URL',
-                'getFrontendUrl'
-            ],
-            [
-                'ALLOW_ORIGINS',
-                'getOrigins'
-            ],
-            [
-                'PORT',
-                'getPort'
-            ],
-            [
-                'MODE',
-                'isProduction'
-            ],
-            [
-                'DB_TYPE',
-                'getTypeOrmConfig'
-            ],
-            [
-                'DB_HOST',
-                'getTypeOrmConfig'
-            ],
-            [
-                'DB_PORT',
-                'getTypeOrmConfig'
-            ],
-            [
-                'DB_USER',
-                'getTypeOrmConfig'
-            ],
-            [
-                'DB_PASSWORD',
-                'getTypeOrmConfig'
-            ],
-            [
-                'DB_NAME',
-                'getTypeOrmConfig'
-            ]
-        ])('should deny direct access to restricted key %s and point to %s()', (key, method)=>{
-            expect(()=>_envconfigservice.envConfig.tryGetValue(key)).toThrow(`Access denied for env key "${key}". Use the method \`${method}()\` instead.`);
-        });
-    });
-    describe('getNumber', ()=>{
-        it('should coerce a numeric env value', ()=>{
-            process.env.SOME_NUMBER = '42';
-            expect(_envconfigservice.envConfig.getNumber('SOME_NUMBER')).toBe(42);
-        });
-        it('should return NaN for a non-numeric value', ()=>{
-            process.env.SOME_NUMBER = 'not-a-number';
-            expect(_envconfigservice.envConfig.getNumber('SOME_NUMBER')).toBeNaN();
-        });
-    });
-    describe('getBoolean', ()=>{
-        it.each([
-            [
-                'true',
-                true
-            ],
-            [
-                'TRUE',
-                true
-            ],
-            [
-                'True',
-                true
-            ],
-            [
-                'false',
-                false
-            ],
-            [
-                'yes',
-                false
-            ],
-            [
-                '',
-                false
-            ]
-        ])('should parse %s as %s', (value, expected)=>{
-            process.env.SOME_BOOL = value;
-            expect(_envconfigservice.envConfig.getBoolean('SOME_BOOL', false)).toBe(expected);
-        });
-    });
-    describe('getPort', ()=>{
-        it('should default to 3000 when PORT is unset', ()=>{
-            delete process.env.PORT;
-            expect(_envconfigservice.envConfig.getPort()).toBe(3000);
-        });
-        it('should return the configured PORT', ()=>{
-            process.env.PORT = '2002';
-            expect(_envconfigservice.envConfig.getPort()).toBe(2002);
-        });
-    });
-    describe('isProduction', ()=>{
-        it('should be true when MODE is unset', ()=>{
-            delete process.env.MODE;
-            expect(_envconfigservice.envConfig.isProduction()).toBe(true);
-        });
-        it('should be false when MODE is "dev" (case-insensitive)', ()=>{
-            process.env.MODE = 'dev';
-            expect(_envconfigservice.envConfig.isProduction()).toBe(false);
-            process.env.MODE = 'DEV';
-            expect(_envconfigservice.envConfig.isProduction()).toBe(false);
-        });
-        it('should be true for any non-DEV mode', ()=>{
-            process.env.MODE = 'production';
-            expect(_envconfigservice.envConfig.isProduction()).toBe(true);
-        });
-    });
-    describe('getOrigins', ()=>{
-        it('should split and trim a comma-separated origin list', ()=>{
-            process.env.ALLOW_ORIGINS = 'http://localhost:2001, http://localhost:3000 ,http://example.com';
-            expect(_envconfigservice.envConfig.getOrigins()).toEqual([
-                'http://localhost:2001',
-                'http://localhost:3000',
-                'http://example.com'
-            ]);
-        });
-        it('should throw when unset since getOrigins requires the value', ()=>{
-            delete process.env.ALLOW_ORIGINS;
-            expect(()=>_envconfigservice.envConfig.getOrigins()).toThrow('Config error - missing env.ALLOW_ORIGINS');
-        });
-    });
-    describe('getTypeOrmConfig', ()=>{
-        it('should apply mysql defaults when DB_TYPE is unset', ()=>{
-            delete process.env.DB_TYPE;
-            delete process.env.DB_HOST;
-            delete process.env.DB_PORT;
-            delete process.env.DB_USER;
-            delete process.env.DB_PASSWORD;
-            delete process.env.DB_NAME;
-            expect(_envconfigservice.envConfig.getTypeOrmConfig()).toEqual({
-                type: 'mysql',
-                host: 'localhost',
-                port: 3306,
-                username: 'root',
-                password: '',
-                database: 'flusys_main'
-            });
-        });
-        it('should default the postgres port to 5432', ()=>{
-            process.env.DB_TYPE = 'postgres';
-            delete process.env.DB_PORT;
-            expect(_envconfigservice.envConfig.getTypeOrmConfig().port).toBe(5432);
-        });
-        it('should use explicit connection values when provided', ()=>{
-            process.env.DB_TYPE = 'postgres';
-            process.env.DB_HOST = 'db.internal';
-            process.env.DB_PORT = '5555';
-            process.env.DB_USER = 'flusys';
-            process.env.DB_PASSWORD = 'secret';
-            process.env.DB_NAME = 'flusys_prod';
-            expect(_envconfigservice.envConfig.getTypeOrmConfig()).toEqual({
-                type: 'postgres',
-                host: 'db.internal',
-                port: 5555,
-                username: 'flusys',
-                password: 'secret',
-                database: 'flusys_prod'
-            });
-        });
-    });
-    describe('getJwtConfig', ()=>{
-        it('should throw when JWT_SECRET is missing', ()=>{
-            delete process.env.JWT_SECRET;
-            process.env.REFRESH_TOKEN_SECRET = 'refresh';
-            expect(()=>_envconfigservice.envConfig.getJwtConfig()).toThrow('Config error - missing env.JWT_SECRET');
-        });
-        it('should throw when REFRESH_TOKEN_SECRET is missing', ()=>{
-            process.env.JWT_SECRET = 'secret';
-            delete process.env.REFRESH_TOKEN_SECRET;
-            expect(()=>_envconfigservice.envConfig.getJwtConfig()).toThrow('Config error - missing env.REFRESH_TOKEN_SECRET');
-        });
-        it('should apply default expirations when unset', ()=>{
-            process.env.JWT_SECRET = 'secret';
-            process.env.REFRESH_TOKEN_SECRET = 'refresh-secret';
-            delete process.env.JWT_EXPIRATION;
-            delete process.env.REFRESH_TOKEN_EXPIRATION;
-            expect(_envconfigservice.envConfig.getJwtConfig()).toEqual({
-                secret: 'secret',
-                expiration: '1h',
-                refreshSecret: 'refresh-secret',
-                refreshExpiration: '7d'
-            });
-        });
-        it('should use explicit expirations when set', ()=>{
-            process.env.JWT_SECRET = 'secret';
-            process.env.JWT_EXPIRATION = '15m';
-            process.env.REFRESH_TOKEN_SECRET = 'refresh-secret';
-            process.env.REFRESH_TOKEN_EXPIRATION = '30d';
-            expect(_envconfigservice.envConfig.getJwtConfig()).toEqual({
-                secret: 'secret',
-                expiration: '15m',
-                refreshSecret: 'refresh-secret',
-                refreshExpiration: '30d'
-            });
-        });
-    });
-    describe('getRedisUrl', ()=>{
-        it('should default to localhost redis', ()=>{
-            delete process.env.REDIS_URL;
-            expect(_envconfigservice.envConfig.getRedisUrl()).toBe('redis://localhost:6379');
-        });
-        it('should return the configured redis url', ()=>{
-            process.env.REDIS_URL = 'redis://redis-host:6380';
-            expect(_envconfigservice.envConfig.getRedisUrl()).toBe('redis://redis-host:6380');
-        });
-    });
-    describe('getMailConfig', ()=>{
-        it('should default to empty strings when unset', ()=>{
-            delete process.env.MAIL_FROM;
-            delete process.env.MAIL_APP_PASSWORD;
-            expect(_envconfigservice.envConfig.getMailConfig()).toEqual({
-                MAIL_FROM: '',
-                MAIL_APP_PASSWORD: ''
-            });
-        });
-        it('should return configured mail settings', ()=>{
-            process.env.MAIL_FROM = 'noreply@flusys.io';
-            process.env.MAIL_APP_PASSWORD = 'app-pass';
-            expect(_envconfigservice.envConfig.getMailConfig()).toEqual({
-                MAIL_FROM: 'noreply@flusys.io',
-                MAIL_APP_PASSWORD: 'app-pass'
-            });
-        });
-    });
-    describe('getTenantId', ()=>{
-        it('should return null when unset', ()=>{
-            delete process.env.TENANT_ID;
-            expect(_envconfigservice.envConfig.getTenantId()).toBeNull();
-        });
-        it('should return the configured tenant id', ()=>{
-            process.env.TENANT_ID = 'tenant-a';
-            expect(_envconfigservice.envConfig.getTenantId()).toBe('tenant-a');
-        });
-    });
-    describe('useTenantMode', ()=>{
-        it('should be false by default', ()=>{
-            delete process.env.USE_TENANT_MODE;
-            expect(_envconfigservice.envConfig.useTenantMode()).toBe(false);
-        });
-        it('should be true when explicitly set', ()=>{
-            process.env.USE_TENANT_MODE = 'true';
-            expect(_envconfigservice.envConfig.useTenantMode()).toBe(true);
-        });
-    });
-    describe('getLogConfig', ()=>{
-        it('should default log level to info in production', ()=>{
-            delete process.env.MODE;
-            delete process.env.LOG_LEVEL;
-            expect(_envconfigservice.envConfig.getLogConfig().level).toBe('info');
-        });
-        it('should default log level to debug outside production', ()=>{
-            process.env.MODE = 'dev';
-            delete process.env.LOG_LEVEL;
-            expect(_envconfigservice.envConfig.getLogConfig().level).toBe('debug');
-        });
-        it('should apply all defaults when unset', ()=>{
-            process.env.MODE = 'dev';
-            delete process.env.LOG_DIR;
-            delete process.env.LOG_LEVEL;
-            delete process.env.LOG_MAX_SIZE;
-            delete process.env.LOG_MAX_FILES;
-            delete process.env.DISABLE_HTTP_LOGGING;
-            expect(_envconfigservice.envConfig.getLogConfig()).toEqual({
-                dir: 'logs',
-                level: 'debug',
-                maxSize: '20m',
-                maxFiles: '14d',
-                disableHttpLogging: false
-            });
-        });
-        it('should honor explicit overrides', ()=>{
-            process.env.LOG_DIR = '/var/log/flusys';
-            process.env.LOG_LEVEL = 'warn';
-            process.env.LOG_MAX_SIZE = '50m';
-            process.env.LOG_MAX_FILES = '30d';
-            process.env.DISABLE_HTTP_LOGGING = 'true';
-            expect(_envconfigservice.envConfig.getLogConfig()).toEqual({
-                dir: '/var/log/flusys',
-                level: 'warn',
-                maxSize: '50m',
-                maxFiles: '30d',
-                disableHttpLogging: true
-            });
-        });
-    });
-    describe('getEnv', ()=>{
-        it('should return the full process.env map', ()=>{
-            process.env.SOME_FLAG = 'x';
-            expect(_envconfigservice.envConfig.getEnv()).toBe(process.env);
-        });
-    });
-});

package/cjs/config/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./env-config.service"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/constants/database.constants.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get DEFAULT_TENANT_HEADER () {
-        return DEFAULT_TENANT_HEADER;
-    },
-    get MODULE_OPTIONS () {
-        return MODULE_OPTIONS;
-    }
-});
-const MODULE_OPTIONS = Symbol('MODULE_OPTIONS');
-const DEFAULT_TENANT_HEADER = 'x-tenant-id';

package/cjs/constants/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./database.constants"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/docs/docs.config.js

@@ -1,276 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get setupModuleSwaggerDocs () {
-        return setupModuleSwaggerDocs;
-    },
-    get setupSwaggerDocs () {
-        return setupSwaggerDocs;
-    }
-});
-const _swagger = require("@nestjs/swagger");
-function filterSchemaProperties(document, exclusions) {
-    if (!exclusions?.length || !document.components?.schemas) {
-        return document;
-    }
-    const schemas = {
-        ...document.components.schemas
-    };
-    for (const exclusion of exclusions){
-        const schema = schemas[exclusion.schemaName];
-        if (schema && typeof schema === 'object' && 'properties' in schema) {
-            const filteredProperties = {
-                ...schema.properties
-            };
-            for (const prop of exclusion.properties){
-                delete filteredProperties[prop];
-            }
-            // Also remove from required array if present
-            const filteredRequired = schema.required?.filter((r)=>!exclusion.properties.includes(r));
-            schemas[exclusion.schemaName] = {
-                ...schema,
-                properties: filteredProperties,
-                ...filteredRequired?.length ? {
-                    required: filteredRequired
-                } : {}
-            };
-        }
-    }
-    return {
-        ...document,
-        components: {
-            ...document.components,
-            schemas
-        }
-    };
-}
-function filterQueryParameters(document, exclusions) {
-    if (!exclusions?.length || !document.paths) {
-        return document;
-    }
-    const filteredPaths = {};
-    for (const [path, pathItem] of Object.entries(document.paths)){
-        const filteredPathItem = {};
-        for (const [method, operation] of Object.entries(pathItem)){
-            // Skip non-operation properties
-            if (!operation || typeof operation !== 'object') {
-                filteredPathItem[method] = operation;
-                continue;
-            }
-            // Check if this endpoint matches any exclusion pattern
-            const matchingExclusions = exclusions.filter((exclusion)=>{
-                const pathMatches = pathMatchesPattern(path, exclusion.pathPattern);
-                const methodMatches = !exclusion.method || exclusion.method === method;
-                return pathMatches && methodMatches;
-            });
-            if (matchingExclusions.length > 0) {
-                // Collect all parameters to exclude
-                const paramsToExclude = new Set();
-                matchingExclusions.forEach((exclusion)=>{
-                    exclusion.parameters.forEach((param)=>paramsToExclude.add(param));
-                });
-                // Filter out excluded query parameters
-                const filteredOperation = {
-                    ...operation
-                };
-                if (Array.isArray(filteredOperation.parameters)) {
-                    filteredOperation.parameters = filteredOperation.parameters.filter((param)=>{
-                        return !(param.in === 'query' && paramsToExclude.has(param.name));
-                    });
-                }
-                filteredPathItem[method] = filteredOperation;
-            } else {
-                filteredPathItem[method] = operation;
-            }
-        }
-        filteredPaths[path] = filteredPathItem;
-    }
-    return {
-        ...document,
-        paths: filteredPaths
-    };
-}
-function filterExamples(document, exclusions) {
-    if (!exclusions?.length || !document.paths) {
-        return document;
-    }
-    const filteredPaths = {};
-    for (const [path, pathItem] of Object.entries(document.paths)){
-        const filteredPathItem = {};
-        for (const [method, operation] of Object.entries(pathItem)){
-            // Skip non-operation properties
-            if (!operation || typeof operation !== 'object') {
-                filteredPathItem[method] = operation;
-                continue;
-            }
-            // Check if this endpoint matches any exclusion pattern
-            const matchingExclusions = exclusions.filter((exclusion)=>{
-                const pathMatches = pathMatchesPattern(path, exclusion.pathPattern);
-                const methodMatches = !exclusion.method || exclusion.method === method;
-                return pathMatches && methodMatches;
-            });
-            if (matchingExclusions.length > 0) {
-                // Collect all examples to exclude
-                const examplesToExclude = new Set();
-                matchingExclusions.forEach((exclusion)=>{
-                    exclusion.examples.forEach((example)=>examplesToExclude.add(example));
-                });
-                // Deep clone the operation to avoid mutating original
-                const filteredOperation = JSON.parse(JSON.stringify(operation));
-                // Filter examples from responses
-                if (filteredOperation.responses) {
-                    for (const [statusCode, response] of Object.entries(filteredOperation.responses)){
-                        const responseObj = response;
-                        if (responseObj?.content) {
-                            const content = responseObj.content;
-                            for (const [mediaType, mediaTypeObj] of Object.entries(content)){
-                                const media = mediaTypeObj;
-                                if (media?.examples && typeof media.examples === 'object') {
-                                    const examples = media.examples;
-                                    for (const exampleName of examplesToExclude){
-                                        delete examples[exampleName];
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                filteredPathItem[method] = filteredOperation;
-            } else {
-                filteredPathItem[method] = operation;
-            }
-        }
-        filteredPaths[path] = filteredPathItem;
-    }
-    return {
-        ...document,
-        paths: filteredPaths
-    };
-}
-function pathMatchesPattern(path, pattern) {
-    // Convert wildcard pattern to regex
-    const regexPattern = pattern.replace(/\*/g, '[^/]+') // * matches any characters except /
-    .replace(/\*\*/g, '.*'); // ** matches any characters including /
-    const regex = new RegExp(`^${regexPattern}$`);
-    return regex.test(path);
-}
-function filterPaths(document, excludePaths) {
-    if (!excludePaths?.length || !document.paths) {
-        return document;
-    }
-    const filteredPaths = {};
-    for (const [path, pathItem] of Object.entries(document.paths)){
-        const isExcluded = excludePaths.some((pattern)=>pathMatchesPattern(path, pattern));
-        if (!isExcluded) {
-            filteredPaths[path] = pathItem;
-        }
-    }
-    return {
-        ...document,
-        paths: filteredPaths
-    };
-}
-function filterDocumentByTags(document, excludeTags) {
-    if (!excludeTags?.length) {
-        return document;
-    }
-    const excludeTagsSet = new Set(excludeTags.map((tag)=>tag.toLowerCase()));
-    // Filter out paths that have any of the excluded tags
-    const filteredPaths = {};
-    for (const [path, pathItem] of Object.entries(document.paths)){
-        const filteredPathItem = {};
-        for (const [method, operation] of Object.entries(pathItem)){
-            // Skip non-operation properties like 'parameters'
-            if (!operation || typeof operation !== 'object' || !('tags' in operation)) {
-                filteredPathItem[method] = operation;
-                continue;
-            }
-            const operationTags = operation.tags || [];
-            const hasExcludedTag = operationTags.some((tag)=>excludeTagsSet.has(tag.toLowerCase()));
-            if (!hasExcludedTag) {
-                filteredPathItem[method] = operation;
-            }
-        }
-        // Only include path if it has at least one operation
-        const hasOperations = Object.keys(filteredPathItem).some((key)=>[
-                'get',
-                'post',
-                'put',
-                'patch',
-                'delete',
-                'options',
-                'head'
-            ].includes(key));
-        if (hasOperations) {
-            filteredPaths[path] = filteredPathItem;
-        }
-    }
-    // Filter out excluded tags from the tags array
-    const filteredTags = document.tags?.filter((tag)=>!excludeTagsSet.has(tag.name.toLowerCase()));
-    return {
-        ...document,
-        paths: filteredPaths,
-        tags: filteredTags
-    };
-}
-function setupModuleSwaggerDocs(app, configs) {
-    configs.forEach((config)=>{
-        const builder = new _swagger.DocumentBuilder().setTitle(config.title).setDescription(config.description).setVersion(config.version || '1.0');
-        // Add bearer auth
-        if (config.bearerAuth) {
-            builder.addBearerAuth();
-        }
-        // Add custom global headers
-        if (config.globalHeaders?.length) {
-            config.globalHeaders.forEach((header)=>{
-                builder.addGlobalParameters({
-                    name: header.name,
-                    in: 'header',
-                    description: header.description,
-                    required: header.required ?? false,
-                    schema: {
-                        type: 'string',
-                        example: header.example || ''
-                    }
-                });
-            });
-        }
-        // Only filter by modules if specified
-        const createDocOptions = config.modules?.length ? {
-            include: config.modules
-        } : {};
-        let document = _swagger.SwaggerModule.createDocument(app, builder.build(), createDocOptions);
-        // Filter out excluded paths
-        if (config.excludePaths?.length) {
-            document = filterPaths(document, config.excludePaths);
-        }
-        // Filter out excluded tags
-        if (config.excludeTags?.length) {
-            document = filterDocumentByTags(document, config.excludeTags);
-        }
-        // Filter out excluded schema properties
-        if (config.excludeSchemaProperties?.length) {
-            document = filterSchemaProperties(document, config.excludeSchemaProperties);
-        }
-        // Filter out excluded query parameters
-        if (config.excludeQueryParameters?.length) {
-            document = filterQueryParameters(document, config.excludeQueryParameters);
-        }
-        // Filter out excluded examples
-        if (config.excludeExamples?.length) {
-            document = filterExamples(document, config.excludeExamples);
-        }
-        _swagger.SwaggerModule.setup(config.path, app, document);
-    });
-}
-function setupSwaggerDocs(app, ...modules) {
-    setupModuleSwaggerDocs(app, modules);
-}