@flusys/nestjs-core 6.0.2 → 6.1.0

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

@@ -0,0 +1,325 @@
+"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);
+        });
+    });
+});