@flusys/nestjs-auth 6.0.2 → 6.1.1

package/cjs/modules/auth.module.spec.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _authmodule = require("./auth.module");
+const _authconstants = require("../config/auth.constants");
+const _controllers = require("../controllers");
+const _services = require("../services");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function providerTokens(providers) {
+    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
+}
+describe('AuthModule', ()=>{
+    describe('forRoot', ()=>{
+        it('should build a non-global module by default with the minimal feature set', ()=>{
+            const dynamicModule = _authmodule.AuthModule.forRoot({
+                bootstrapAppConfig: {
+                    enableEmailVerification: false
+                }
+            });
+            expect(dynamicModule.module).toBe(_authmodule.AuthModule);
+            expect(dynamicModule.global).toBe(false);
+            expect(dynamicModule.controllers).toEqual([
+                _controllers.AuthenticationController,
+                _controllers.UserController
+            ]);
+            expect(providerTokens(dynamicModule.providers)).not.toContain(_services.AuthEmailService);
+            expect(providerTokens(dynamicModule.providers)).not.toContain(_services.CompanyService);
+        });
+        it('should respect global: true', ()=>{
+            const dynamicModule = _authmodule.AuthModule.forRoot({
+                global: true
+            });
+            expect(dynamicModule.global).toBe(true);
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            const dynamicModule = _authmodule.AuthModule.forRoot({
+                includeController: false
+            });
+            expect(dynamicModule.controllers).toEqual([]);
+        });
+        it('should enable email verification by default (bootstrapAppConfig omitted)', ()=>{
+            const dynamicModule = _authmodule.AuthModule.forRoot({});
+            expect(dynamicModule.controllers).toContain(_controllers.EmailVerificationController);
+            expect(providerTokens(dynamicModule.providers)).toContain(_services.AuthEmailService);
+            expect(dynamicModule.exports).toContain(_services.AuthEmailService);
+        });
+        it('should omit email verification controller/provider/export when explicitly disabled', ()=>{
+            const dynamicModule = _authmodule.AuthModule.forRoot({
+                bootstrapAppConfig: {
+                    enableEmailVerification: false
+                }
+            });
+            expect(dynamicModule.controllers).not.toContain(_controllers.EmailVerificationController);
+            expect(providerTokens(dynamicModule.providers)).not.toContain(_services.AuthEmailService);
+            expect(dynamicModule.exports).not.toContain(_services.AuthEmailService);
+        });
+        it('should add company controllers/providers/exports when enableCompanyFeature is true', ()=>{
+            const dynamicModule = _authmodule.AuthModule.forRoot({
+                bootstrapAppConfig: {
+                    enableCompanyFeature: true
+                }
+            });
+            expect(dynamicModule.controllers).toEqual(expect.arrayContaining([
+                _controllers.CompanySelectionController,
+                _controllers.CompanyController,
+                _controllers.BranchController,
+                _controllers.UserPermissionController
+            ]));
+            expect(providerTokens(dynamicModule.providers)).toEqual(expect.arrayContaining([
+                _services.CompanySelectionSessionService,
+                _services.CompanyService,
+                _services.BranchService,
+                _services.UserPermissionService
+            ]));
+            expect(dynamicModule.exports).toEqual(expect.arrayContaining([
+                _services.CompanyService,
+                _services.BranchService,
+                _services.UserPermissionService
+            ]));
+        });
+        it('should register an AUTH_MODULE_OPTIONS provider carrying the given options', ()=>{
+            const options = {
+                bootstrapAppConfig: {
+                    enableCompanyFeature: true
+                }
+            };
+            const dynamicModule = _authmodule.AuthModule.forRoot(options);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _authconstants.AUTH_MODULE_OPTIONS);
+            expect(optionsProvider.useValue).toBe(options);
+        });
+        it('should append any caller-supplied extra providers', ()=>{
+            const extraProvider = {
+                provide: 'EXTRA',
+                useValue: 'x'
+            };
+            const dynamicModule = _authmodule.AuthModule.forRoot({
+                providers: [
+                    extraProvider
+                ]
+            });
+            expect(dynamicModule.providers).toEqual(expect.arrayContaining([
+                extraProvider
+            ]));
+        });
+    });
+    describe('forRootAsync', ()=>{
+        it('should default AUTH_MODULE_OPTIONS to the static options when no useFactory/useClass/useExisting is given', async ()=>{
+            const dynamicModule = _authmodule.AuthModule.forRootAsync({
+                bootstrapAppConfig: {},
+                global: true
+            });
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _authconstants.AUTH_MODULE_OPTIONS);
+            expect(optionsProvider.useValue).toEqual({
+                global: true,
+                includeController: undefined,
+                bootstrapAppConfig: {}
+            });
+        });
+        it('should resolve config via useFactory and merge it with the static options', async ()=>{
+            const useFactory = jest.fn().mockResolvedValue({
+                jwtSecret: 'from-factory'
+            });
+            const dynamicModule = _authmodule.AuthModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useFactory,
+                inject: [
+                    'SOME_TOKEN'
+                ]
+            });
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _authconstants.AUTH_MODULE_OPTIONS);
+            expect(optionsProvider.inject).toEqual([
+                'SOME_TOKEN'
+            ]);
+            const resolved = await optionsProvider.useFactory('injected-value');
+            expect(useFactory).toHaveBeenCalledWith('injected-value');
+            expect(resolved).toEqual({
+                global: undefined,
+                includeController: undefined,
+                bootstrapAppConfig: {},
+                config: {
+                    jwtSecret: 'from-factory'
+                }
+            });
+        });
+        it('should resolve config via a useClass factory', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createAuthOptions", jest.fn().mockResolvedValue({
+                        jwtSecret: 'from-class'
+                    }));
+                }
+            };
+            const dynamicModule = _authmodule.AuthModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useClass: MyOptionsFactory
+            });
+            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
+            expect(classProvider.useClass).toBe(MyOptionsFactory);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _authconstants.AUTH_MODULE_OPTIONS);
+            expect(optionsProvider.inject).toEqual([
+                MyOptionsFactory
+            ]);
+            const factoryInstance = new MyOptionsFactory();
+            const resolved = await optionsProvider.useFactory(factoryInstance);
+            expect(factoryInstance.createAuthOptions).toHaveBeenCalled();
+            expect(resolved.config).toEqual({
+                jwtSecret: 'from-class'
+            });
+        });
+        it('should resolve config via a useExisting factory', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createAuthOptions", jest.fn().mockResolvedValue({
+                        jwtSecret: 'from-existing'
+                    }));
+                }
+            };
+            const dynamicModule = _authmodule.AuthModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useExisting: MyOptionsFactory
+            });
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _authconstants.AUTH_MODULE_OPTIONS);
+            expect(optionsProvider.inject).toEqual([
+                MyOptionsFactory
+            ]);
+            const factoryInstance = new MyOptionsFactory();
+            const resolved = await optionsProvider.useFactory(factoryInstance);
+            expect(resolved.config).toEqual({
+                jwtSecret: 'from-existing'
+            });
+        });
+        it('should forward the async `imports` array into the built module', ()=>{
+            let FakeImportedModule = class FakeImportedModule {
+            };
+            const dynamicModule = _authmodule.AuthModule.forRootAsync({
+                bootstrapAppConfig: {},
+                imports: [
+                    FakeImportedModule
+                ]
+            });
+            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
+                FakeImportedModule
+            ]));
+        });
+        it('should append any caller-supplied extra providers alongside the async options provider', ()=>{
+            const extraProvider = {
+                provide: 'EXTRA',
+                useValue: 'x'
+            };
+            const dynamicModule = _authmodule.AuthModule.forRootAsync({
+                bootstrapAppConfig: {},
+                providers: [
+                    extraProvider
+                ]
+            });
+            expect(dynamicModule.providers).toEqual(expect.arrayContaining([
+                extraProvider
+            ]));
+        });
+    });
+    describe('getEntities', ()=>{
+        it('should delegate to getAuthEntitiesByConfig with the bootstrap flags', ()=>{
+            const entitiesWithDefaults = _authmodule.AuthModule.getEntities({});
+            const entitiesWithCompany = _authmodule.AuthModule.getEntities({
+                enableCompanyFeature: true
+            });
+            expect(entitiesWithDefaults.length).toBeLessThan(entitiesWithCompany.length);
+        });
+    });
+});

package/cjs/services/auth-config.service.spec.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _config = require("@flusys/nestjs-core/config");
+const _authconfigservice = require("./auth-config.service");
+jest.mock('@flusys/nestjs-core/config', ()=>({
+        envConfig: {
+            isProduction: jest.fn().mockReturnValue(false)
+        }
+    }));
+describe('AuthConfigService', ()=>{
+    afterEach(()=>{
+        jest.clearAllMocks();
+    });
+    describe('with no injected options', ()=>{
+        it('defaults database mode to single and company feature to disabled', ()=>{
+            const service = new _authconfigservice.AuthConfigService();
+            expect(service.getDatabaseMode()).toBe('single');
+            expect(service.isMultiTenant()).toBe(false);
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+            expect(service.isEmailVerificationEnabled()).toBe(true);
+            expect(service.isPermissionModeFound()).toBe(false);
+        });
+        it('throws when reading the JWT secret without configuration', ()=>{
+            const service = new _authconfigservice.AuthConfigService();
+            expect(()=>service.getJwtSecret()).toThrow(_common.InternalServerErrorException);
+        });
+        it('falls back to the JWT secret for refresh token secret outside production', ()=>{
+            const service = new _authconfigservice.AuthConfigService({
+                global: false,
+                includeController: true,
+                config: {
+                    jwtSecret: 'shared-secret'
+                }
+            });
+            expect(service.getRefreshTokenSecret()).toBe('shared-secret');
+        });
+        it('returns default JWT expiration and refresh token expiration', ()=>{
+            const service = new _authconfigservice.AuthConfigService();
+            expect(service.getJwtExpiration()).toBe('1h');
+            expect(service.getRefreshTokenExpiration()).toBe('7d');
+            expect(service.getRefreshTokenCookieName()).toBe('fsn_refresh_token');
+        });
+    });
+    describe('with injected options', ()=>{
+        function buildOptions(overrides = {}) {
+            return {
+                global: false,
+                includeController: true,
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: true,
+                    enableEmailVerification: false,
+                    permissionMode: 'RBAC'
+                },
+                config: {
+                    jwtSecret: 'jwt-secret',
+                    jwtExpiration: '30m',
+                    refreshTokenSecret: 'refresh-secret',
+                    refreshTokenExpiration: '14d',
+                    refreshTokenCookieName: 'custom_cookie'
+                },
+                ...overrides
+            };
+        }
+        it('reflects multi-tenant database mode', ()=>{
+            const service = new _authconfigservice.AuthConfigService(buildOptions());
+            expect(service.getDatabaseMode()).toBe('multi-tenant');
+            expect(service.isMultiTenant()).toBe(true);
+        });
+        it('reflects enabled company feature and email verification flags', ()=>{
+            const service = new _authconfigservice.AuthConfigService(buildOptions());
+            expect(service.isCompanyFeatureEnabled()).toBe(true);
+            expect(service.isEmailVerificationEnabled()).toBe(false);
+            expect(service.isPermissionModeFound()).toBe(true);
+        });
+        it('returns configured JWT and refresh token values', ()=>{
+            const service = new _authconfigservice.AuthConfigService(buildOptions());
+            expect(service.getJwtSecret()).toBe('jwt-secret');
+            expect(service.getJwtExpiration()).toBe('30m');
+            expect(service.getRefreshTokenSecret()).toBe('refresh-secret');
+            expect(service.getRefreshTokenExpiration()).toBe('14d');
+            expect(service.getRefreshTokenCookieName()).toBe('custom_cookie');
+        });
+        it('throws in production when refresh token secret is missing (security: prevents shared-secret fallback)', ()=>{
+            _config.envConfig.isProduction.mockReturnValue(true);
+            const service = new _authconfigservice.AuthConfigService(buildOptions({
+                config: {
+                    jwtSecret: 'jwt-secret'
+                }
+            }));
+            expect(()=>service.getRefreshTokenSecret()).toThrow(_common.InternalServerErrorException);
+        });
+    });
+});

package/cjs/services/auth-datasource.provider.spec.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _nestjsshared = require("@flusys/nestjs-shared");
+const _authdatasourceprovider = require("./auth-datasource.provider");
+function buildOptions(overrides = {}) {
+    return {
+        global: false,
+        includeController: true,
+        bootstrapAppConfig: {
+            databaseMode: 'single',
+            enableCompanyFeature: false,
+            enableEmailVerification: true
+        },
+        ...overrides
+    };
+}
+describe('AuthDataSourceProvider', ()=>{
+    afterEach(()=>{
+        jest.restoreAllMocks();
+    });
+    describe('isCompanyFeatureEnabled', ()=>{
+        it('returns false by default when bootstrap config disables it', ()=>{
+            const provider = new _authdatasourceprovider.AuthDataSourceProvider(buildOptions());
+            expect(provider.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('returns true when bootstrap config enables it', ()=>{
+            const provider = new _authdatasourceprovider.AuthDataSourceProvider(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(provider.isCompanyFeatureEnabled()).toBe(true);
+        });
+        it('prefers the tenant override over bootstrap config', ()=>{
+            const provider = new _authdatasourceprovider.AuthDataSourceProvider(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: false
+                }
+            }));
+            expect(provider.isCompanyFeatureEnabled({
+                enableCompanyFeature: true
+            })).toBe(true);
+        });
+        it('defaults to false when no bootstrap config and no tenant override is present', ()=>{
+            const provider = new _authdatasourceprovider.AuthDataSourceProvider(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(provider.isCompanyFeatureEnabled()).toBe(false);
+        });
+    });
+    describe('isEmailVerificationEnabled', ()=>{
+        it('returns true by default (feature defaults to enabled)', ()=>{
+            const provider = new _authdatasourceprovider.AuthDataSourceProvider(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(provider.isEmailVerificationEnabled()).toBe(true);
+        });
+        it('returns false when bootstrap config disables it', ()=>{
+            const provider = new _authdatasourceprovider.AuthDataSourceProvider(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: false,
+                    enableEmailVerification: false
+                }
+            }));
+            expect(provider.isEmailVerificationEnabled()).toBe(false);
+        });
+        it('prefers the tenant override over bootstrap config', ()=>{
+            const provider = new _authdatasourceprovider.AuthDataSourceProvider(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: true,
+                    enableEmailVerification: true
+                }
+            }));
+            expect(provider.isEmailVerificationEnabled({
+                enableEmailVerification: false
+            })).toBe(false);
+        });
+    });
+    describe('getAuthEntities', ()=>{
+        it('returns only base entities when company feature and email verification are disabled', async ()=>{
+            const provider = new _authdatasourceprovider.AuthDataSourceProvider(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: false,
+                    enableEmailVerification: false
+                }
+            }));
+            const entities = await provider.getAuthEntities();
+            const names = entities.map((e)=>e.name);
+            expect(names).toEqual(expect.arrayContaining([
+                'AppUser',
+                'UserToken'
+            ]));
+            expect(names).not.toContain('Company');
+            expect(names).not.toContain('PendingRegistration');
+        });
+        it('includes company entities when company feature is enabled', async ()=>{
+            const provider = new _authdatasourceprovider.AuthDataSourceProvider(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true,
+                    enableEmailVerification: false
+                }
+            }));
+            const entities = await provider.getAuthEntities();
+            const names = entities.map((e)=>e.name);
+            expect(names).toEqual(expect.arrayContaining([
+                'AppUser',
+                'UserToken',
+                'Company',
+                'CompanyBranch',
+                'UserCompanyPermission'
+            ]));
+        });
+        it('includes pending registration entity when email verification is enabled', async ()=>{
+            const provider = new _authdatasourceprovider.AuthDataSourceProvider(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: false,
+                    enableEmailVerification: true
+                }
+            }));
+            const entities = await provider.getAuthEntities();
+            const names = entities.map((e)=>e.name);
+            expect(names).toContain('PendingRegistration');
+        });
+    });
+    describe('createDataSourceFromConfig', ()=>{
+        it('forwards the config and resolved auth entities to the parent implementation', async ()=>{
+            const fakeDataSource = {
+                isInitialized: true
+            };
+            const parentSpy = jest.spyOn(_nestjsshared.MultiTenantDataSourceService.prototype, 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
+            const provider = new _authdatasourceprovider.AuthDataSourceProvider(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true,
+                    enableEmailVerification: true
+                }
+            }));
+            const config = {
+                type: 'postgres',
+                host: 'localhost'
+            };
+            const result = await provider.createDataSourceFromConfig(config);
+            expect(result).toBe(fakeDataSource);
+            expect(parentSpy).toHaveBeenCalledWith(config, expect.any(Array));
+            const forwardedEntityNames = parentSpy.mock.calls[0][1].map((e)=>e.name);
+            expect(forwardedEntityNames).toEqual(expect.arrayContaining([
+                'AppUser',
+                'Company'
+            ]));
+        });
+    });
+});