@flusys/nestjs-core 6.0.2 → 6.1.0

package/cjs/utils/datasource-config.builder.spec.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _datasourceconfigbuilder = require("./datasource-config.builder");
+describe('datasource-config.builder', ()=>{
+    describe('buildDataSourceOptions', ()=>{
+        it('should build options with synchronize disabled', ()=>{
+            const config = {
+                type: 'postgres',
+                host: 'localhost',
+                port: 5432,
+                username: 'root',
+                password: 'pw',
+                database: 'flusys'
+            };
+            const options = (0, _datasourceconfigbuilder.buildDataSourceOptions)(config, [
+                Object
+            ], 'migrations/default', 'custom_migrations');
+            expect(options).toEqual({
+                type: 'postgres',
+                host: 'localhost',
+                port: 5432,
+                username: 'root',
+                password: 'pw',
+                database: 'flusys',
+                entities: [
+                    Object
+                ],
+                migrations: [
+                    'migrations/default'
+                ],
+                migrationsTableName: 'custom_migrations',
+                synchronize: false
+            });
+        });
+        it('should default database to an empty string and table name to "migrations"', ()=>{
+            const config = {
+                type: 'sqlite'
+            };
+            const options = (0, _datasourceconfigbuilder.buildDataSourceOptions)(config, [], 'migrations/default');
+            expect(options.database).toBe('');
+            expect(options.migrationsTableName).toBe('migrations');
+        });
+    });
+    describe('getMigrationsFolderPath', ()=>{
+        it('should use "default" when no tenantId is given', ()=>{
+            expect((0, _datasourceconfigbuilder.getMigrationsFolderPath)('migrations')).toBe('migrations/default');
+        });
+        it('should namespace the folder by tenant', ()=>{
+            expect((0, _datasourceconfigbuilder.getMigrationsFolderPath)('migrations', 'tenant-a')).toBe('migrations/tenant-a');
+        });
+    });
+    describe('getMigrationsGlobPattern', ()=>{
+        it('should build a glob matching ts and js migration files', ()=>{
+            expect((0, _datasourceconfigbuilder.getMigrationsGlobPattern)('migrations', 'tenant-a')).toBe('migrations/tenant-a/*{.ts,.js}');
+        });
+        it('should fall back to the default folder', ()=>{
+            expect((0, _datasourceconfigbuilder.getMigrationsGlobPattern)('migrations')).toBe('migrations/default/*{.ts,.js}');
+        });
+    });
+    describe('getDatabaseForTenant', ()=>{
+        const baseConfig = {
+            defaultDatabaseConfig: {
+                type: 'postgres',
+                database: 'flusys_default'
+            },
+            migrationsPath: 'migrations',
+            entities: []
+        };
+        it('should return the default tenant config when tenantId is omitted', ()=>{
+            const result = (0, _datasourceconfigbuilder.getDatabaseForTenant)(baseConfig);
+            expect(result.database).toBe('flusys_default');
+            expect(result.tenant).toBeUndefined();
+            expect(result.tenantConfig).toEqual({
+                id: 'default',
+                database: 'flusys_default',
+                enableCompanyFeature: false,
+                permissionMode: 'FULL'
+            });
+        });
+        it('should apply bootstrap feature flags to the default tenant config', ()=>{
+            const config = {
+                ...baseConfig,
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true,
+                    permissionMode: 'RBAC'
+                }
+            };
+            const result = (0, _datasourceconfigbuilder.getDatabaseForTenant)(config);
+            expect(result.tenantConfig.enableCompanyFeature).toBe(true);
+            expect(result.tenantConfig.permissionMode).toBe('RBAC');
+        });
+        it('should resolve an explicit tenant by id', ()=>{
+            const config = {
+                ...baseConfig,
+                tenants: [
+                    {
+                        id: 'tenant-a',
+                        database: 'db_a'
+                    },
+                    {
+                        id: 'tenant-b',
+                        database: 'db_b'
+                    }
+                ]
+            };
+            const result = (0, _datasourceconfigbuilder.getDatabaseForTenant)(config, 'tenant-b');
+            expect(result.database).toBe('db_b');
+            expect(result.tenant?.id).toBe('tenant-b');
+            expect(result.tenantConfig.id).toBe('tenant-b');
+        });
+        it('should throw a descriptive error for an unknown tenant id', ()=>{
+            const config = {
+                ...baseConfig,
+                tenants: [
+                    {
+                        id: 'tenant-a',
+                        database: 'db_a'
+                    }
+                ]
+            };
+            expect(()=>(0, _datasourceconfigbuilder.getDatabaseForTenant)(config, 'unknown')).toThrow("Tenant 'unknown' not found. Available: tenant-a");
+        });
+    });
+    describe('resolveDatabaseConnection', ()=>{
+        const baseConfig = {
+            defaultDatabaseConfig: {
+                type: 'postgres',
+                host: 'default-host',
+                port: 5432,
+                username: 'default-user',
+                password: 'default-pw',
+                database: 'flusys_default'
+            },
+            migrationsPath: 'migrations',
+            entities: []
+        };
+        it('should return the default connection when no tenant matches', ()=>{
+            const result = (0, _datasourceconfigbuilder.resolveDatabaseConnection)(baseConfig);
+            expect(result).toEqual(baseConfig.defaultDatabaseConfig);
+        });
+        it('should overlay tenant-specific fields onto the default connection', ()=>{
+            const config = {
+                ...baseConfig,
+                tenants: [
+                    {
+                        id: 'tenant-a',
+                        database: 'db_a',
+                        host: 'tenant-host'
+                    }
+                ]
+            };
+            const result = (0, _datasourceconfigbuilder.resolveDatabaseConnection)(config, 'tenant-a');
+            expect(result).toEqual({
+                type: 'postgres',
+                host: 'tenant-host',
+                port: 5432,
+                username: 'default-user',
+                password: 'default-pw',
+                database: 'db_a'
+            });
+        });
+        it('should fall back to default connection fields when tenant omits them', ()=>{
+            const config = {
+                ...baseConfig,
+                tenants: [
+                    {
+                        id: 'tenant-a',
+                        database: 'db_a'
+                    }
+                ]
+            };
+            const result = (0, _datasourceconfigbuilder.resolveDatabaseConnection)(config, 'tenant-a');
+            expect(result.host).toBe('default-host');
+            expect(result.port).toBe(5432);
+            expect(result.username).toBe('default-user');
+        });
+    });
+    describe('resolveEntities', ()=>{
+        it('should return the entities array directly when not a function', ()=>{
+            const config = {
+                entities: [
+                    Object,
+                    String
+                ]
+            };
+            expect((0, _datasourceconfigbuilder.resolveEntities)(config)).toEqual([
+                Object,
+                String
+            ]);
+        });
+        it('should invoke the resolver function with tenant config', ()=>{
+            const resolver = jest.fn().mockReturnValue([
+                Number
+            ]);
+            const config = {
+                entities: resolver
+            };
+            const tenantConfig = {
+                id: 'tenant-a',
+                database: 'db_a'
+            };
+            const result = (0, _datasourceconfigbuilder.resolveEntities)(config, tenantConfig);
+            expect(resolver).toHaveBeenCalledWith(tenantConfig);
+            expect(result).toEqual([
+                Number
+            ]);
+        });
+    });
+    describe('getActiveTenants', ()=>{
+        it('should return an empty array when no tenants are configured', ()=>{
+            const config = {
+                tenants: undefined
+            };
+            expect((0, _datasourceconfigbuilder.getActiveTenants)(config)).toEqual([]);
+        });
+        it('should return the configured tenants', ()=>{
+            const tenants = [
+                {
+                    id: 'a',
+                    database: 'db_a'
+                }
+            ];
+            const config = {
+                tenants
+            };
+            expect((0, _datasourceconfigbuilder.getActiveTenants)(config)).toBe(tenants);
+        });
+    });
+});

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

@@ -0,0 +1,321 @@
+import { envConfig } from './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(envConfig.tryGetValue('CUSTOM_KEY')).toBe('custom-value');
+        });
+        it('should return empty string when missing and throwOnMissing is false', ()=>{
+            delete process.env.MISSING_KEY;
+            expect(envConfig.tryGetValue('MISSING_KEY', false)).toBe('');
+        });
+        it('should throw when missing and throwOnMissing is true', ()=>{
+            delete process.env.MISSING_KEY;
+            expect(()=>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(()=>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(envConfig.getNumber('SOME_NUMBER')).toBe(42);
+        });
+        it('should return NaN for a non-numeric value', ()=>{
+            process.env.SOME_NUMBER = 'not-a-number';
+            expect(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(envConfig.getBoolean('SOME_BOOL', false)).toBe(expected);
+        });
+    });
+    describe('getPort', ()=>{
+        it('should default to 3000 when PORT is unset', ()=>{
+            delete process.env.PORT;
+            expect(envConfig.getPort()).toBe(3000);
+        });
+        it('should return the configured PORT', ()=>{
+            process.env.PORT = '2002';
+            expect(envConfig.getPort()).toBe(2002);
+        });
+    });
+    describe('isProduction', ()=>{
+        it('should be true when MODE is unset', ()=>{
+            delete process.env.MODE;
+            expect(envConfig.isProduction()).toBe(true);
+        });
+        it('should be false when MODE is "dev" (case-insensitive)', ()=>{
+            process.env.MODE = 'dev';
+            expect(envConfig.isProduction()).toBe(false);
+            process.env.MODE = 'DEV';
+            expect(envConfig.isProduction()).toBe(false);
+        });
+        it('should be true for any non-DEV mode', ()=>{
+            process.env.MODE = 'production';
+            expect(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(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(()=>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(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(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(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(()=>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(()=>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(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(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(envConfig.getRedisUrl()).toBe('redis://localhost:6379');
+        });
+        it('should return the configured redis url', ()=>{
+            process.env.REDIS_URL = 'redis://redis-host:6380';
+            expect(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(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(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(envConfig.getTenantId()).toBeNull();
+        });
+        it('should return the configured tenant id', ()=>{
+            process.env.TENANT_ID = 'tenant-a';
+            expect(envConfig.getTenantId()).toBe('tenant-a');
+        });
+    });
+    describe('useTenantMode', ()=>{
+        it('should be false by default', ()=>{
+            delete process.env.USE_TENANT_MODE;
+            expect(envConfig.useTenantMode()).toBe(false);
+        });
+        it('should be true when explicitly set', ()=>{
+            process.env.USE_TENANT_MODE = 'true';
+            expect(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(envConfig.getLogConfig().level).toBe('info');
+        });
+        it('should default log level to debug outside production', ()=>{
+            process.env.MODE = 'dev';
+            delete process.env.LOG_LEVEL;
+            expect(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(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(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(envConfig.getEnv()).toBe(process.env);
+        });
+    });
+});