@flusys/nestjs-auth 6.0.2 → 6.1.1

package/cjs/controllers/email-verification.controller.spec.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _emailverificationcontroller = require("./email-verification.controller");
+function buildRequest() {
+    return {
+        headers: {},
+        get: jest.fn((h)=>h === 'host' ? 'app.example.com' : undefined),
+        protocol: 'https'
+    };
+}
+describe('EmailVerificationController', ()=>{
+    let controller;
+    let mockAuthService;
+    let mockAuthEmailService;
+    let mockAuthConfig;
+    let mockDataSourceProvider;
+    beforeEach(()=>{
+        mockAuthService = {
+            createUserFromPendingRegistration: jest.fn()
+        };
+        mockAuthEmailService = {
+            forgotPassword: jest.fn(),
+            resetPassword: jest.fn(),
+            resendVerificationEmail: jest.fn(),
+            verifyEmail: jest.fn()
+        };
+        mockAuthConfig = {};
+        mockDataSourceProvider = {
+            isEmailVerificationEnabled: jest.fn().mockReturnValue(true)
+        };
+        controller = new _emailverificationcontroller.EmailVerificationController(mockAuthService, mockAuthEmailService, mockAuthConfig, mockDataSourceProvider);
+    });
+    describe('when email verification is disabled for the tenant', ()=>{
+        beforeEach(()=>{
+            mockDataSourceProvider.isEmailVerificationEnabled.mockReturnValue(false);
+        });
+        it('rejects forgotPassword', async ()=>{
+            await expect(controller.forgotPassword(buildRequest(), {
+                email: 'a@example.com'
+            })).rejects.toThrow(_common.BadRequestException);
+        });
+        it('rejects resetPassword', async ()=>{
+            await expect(controller.resetPassword({
+                token: 't',
+                newPassword: 'New1!aaaa'
+            })).rejects.toThrow(_common.BadRequestException);
+        });
+        it('rejects resendVerification', async ()=>{
+            await expect(controller.resendVerification(buildRequest(), {
+                email: 'a@example.com'
+            })).rejects.toThrow(_common.BadRequestException);
+        });
+        it('rejects verifyEmail', async ()=>{
+            await expect(controller.verifyEmail({
+                token: 't'
+            })).rejects.toThrow(_common.BadRequestException);
+        });
+    });
+    describe('forgotPassword', ()=>{
+        it('delegates to authEmailService with a built frontend reset URL', async ()=>{
+            mockAuthEmailService.forgotPassword.mockResolvedValue({
+                success: true,
+                message: 'sent',
+                messageKey: 'auth.password.reset.email.sent'
+            });
+            const result = await controller.forgotPassword(buildRequest(), {
+                email: 'a@example.com'
+            });
+            expect(mockAuthEmailService.forgotPassword).toHaveBeenCalledWith('a@example.com', expect.any(String));
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('resetPassword', ()=>{
+        it('delegates to authEmailService.resetPassword', async ()=>{
+            mockAuthEmailService.resetPassword.mockResolvedValue({
+                success: true,
+                message: 'done',
+                messageKey: 'auth.password.reset.success'
+            });
+            const result = await controller.resetPassword({
+                token: 'tok',
+                newPassword: 'New1!aaaa'
+            });
+            expect(mockAuthEmailService.resetPassword).toHaveBeenCalledWith('tok', 'New1!aaaa');
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('resendVerification', ()=>{
+        it('delegates to authEmailService.resendVerificationEmail', async ()=>{
+            mockAuthEmailService.resendVerificationEmail.mockResolvedValue({
+                success: true,
+                message: 'sent',
+                messageKey: 'email.verification.resend.success'
+            });
+            await controller.resendVerification(buildRequest(), {
+                email: 'a@example.com'
+            });
+            expect(mockAuthEmailService.resendVerificationEmail).toHaveBeenCalledWith('a@example.com', expect.any(String));
+        });
+    });
+    describe('verifyEmail', ()=>{
+        it('completes registration when the token resolves a pending registration', async ()=>{
+            mockAuthEmailService.verifyEmail.mockResolvedValue({
+                type: 'pending',
+                pending: {
+                    id: 'pending-1'
+                }
+            });
+            mockAuthService.createUserFromPendingRegistration.mockResolvedValue({
+                accessToken: 'a'
+            });
+            const result = await controller.verifyEmail({
+                token: 'tok'
+            });
+            expect(mockAuthService.createUserFromPendingRegistration).toHaveBeenCalledWith({
+                id: 'pending-1'
+            });
+            expect(result.data).toEqual({
+                accessToken: 'a'
+            });
+        });
+        it('returns the verification message when the token verifies an existing user token', async ()=>{
+            mockAuthEmailService.verifyEmail.mockResolvedValue({
+                type: 'verified',
+                message: 'Email has been verified successfully.',
+                messageKey: 'email.verification.success'
+            });
+            const result = await controller.verifyEmail({
+                token: 'tok'
+            });
+            expect(result).toEqual({
+                success: true,
+                message: 'Email has been verified successfully.',
+                messageKey: 'email.verification.success'
+            });
+            expect(mockAuthService.createUserFromPendingRegistration).not.toHaveBeenCalled();
+        });
+    });
+});

package/cjs/controllers/user-permission.controller.spec.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _userpermissioncontroller = require("./user-permission.controller");
+const _usercompanypermissionentity = require("../entities/user-company-permission.entity");
+describe('UserPermissionController', ()=>{
+    let controller;
+    let mockPermissionService;
+    beforeEach(()=>{
+        mockPermissionService = {
+            findUserCompanies: jest.fn(),
+            findUserBranches: jest.fn(),
+            assignPermission: jest.fn(),
+            revokePermission: jest.fn()
+        };
+        controller = new _userpermissioncontroller.UserPermissionController(mockPermissionService);
+    });
+    describe('assignUserCompany', ()=>{
+        it('assigns and revokes company permissions in a single batch', async ()=>{
+            const result = await controller.assignUserCompany({
+                userId: 'user-1',
+                items: [
+                    {
+                        targetId: 'company-1',
+                        isAdd: true
+                    },
+                    {
+                        targetId: 'company-2',
+                        isAdd: false
+                    }
+                ]
+            });
+            expect(mockPermissionService.assignPermission).toHaveBeenCalledWith('user-1', 'company-1', _usercompanypermissionentity.PermissionType.COMPANY);
+            expect(mockPermissionService.revokePermission).toHaveBeenCalledWith('user-1', 'company-2', _usercompanypermissionentity.PermissionType.COMPANY);
+            expect(result.messageVariables).toEqual({
+                added: 1,
+                removed: 1
+            });
+        });
+    });
+    describe('getUserCompanies', ()=>{
+        it('maps permission entities to the response DTO shape', async ()=>{
+            mockPermissionService.findUserCompanies.mockResolvedValue([
+                {
+                    id: 'perm-1',
+                    userId: 'user-1',
+                    targetId: 'company-1',
+                    company: {
+                        id: 'company-1',
+                        name: 'Acme',
+                        slug: 'acme'
+                    }
+                }
+            ]);
+            const result = await controller.getUserCompanies('user-1');
+            expect(result.data).toEqual([
+                {
+                    id: 'perm-1',
+                    userId: 'user-1',
+                    companyId: 'company-1',
+                    companyName: 'Acme',
+                    companySlug: 'acme'
+                }
+            ]);
+        });
+        it('falls back to targetId and empty strings when the company relation is missing', async ()=>{
+            mockPermissionService.findUserCompanies.mockResolvedValue([
+                {
+                    id: 'perm-1',
+                    userId: 'user-1',
+                    targetId: 'company-1',
+                    company: undefined
+                }
+            ]);
+            const result = await controller.getUserCompanies('user-1');
+            expect(result.data[0]).toEqual({
+                id: 'perm-1',
+                userId: 'user-1',
+                companyId: 'company-1',
+                companyName: '',
+                companySlug: ''
+            });
+        });
+    });
+    describe('assignUserBranch', ()=>{
+        it('assigns and revokes branch permissions in a single batch', async ()=>{
+            const result = await controller.assignUserBranch({
+                userId: 'user-1',
+                items: [
+                    {
+                        targetId: 'branch-1',
+                        isAdd: true
+                    }
+                ]
+            });
+            expect(mockPermissionService.assignPermission).toHaveBeenCalledWith('user-1', 'branch-1', _usercompanypermissionentity.PermissionType.BRANCH);
+            expect(result.messageVariables).toEqual({
+                added: 1,
+                removed: 0
+            });
+        });
+    });
+    describe('getUserBranches', ()=>{
+        it('maps permission entities to the response DTO shape', async ()=>{
+            mockPermissionService.findUserBranches.mockResolvedValue([
+                {
+                    id: 'perm-1',
+                    userId: 'user-1',
+                    targetId: 'branch-1',
+                    branch: {
+                        id: 'branch-1',
+                        name: 'Main',
+                        slug: 'main',
+                        companyId: 'company-1'
+                    }
+                }
+            ]);
+            const result = await controller.getUserBranches('user-1', 'company-1');
+            expect(mockPermissionService.findUserBranches).toHaveBeenCalledWith('user-1', 'company-1');
+            expect(result.data).toEqual([
+                {
+                    id: 'perm-1',
+                    userId: 'user-1',
+                    branchId: 'branch-1',
+                    branchName: 'Main',
+                    branchSlug: 'main',
+                    companyId: 'company-1'
+                }
+            ]);
+        });
+        it('supports an optional companyId filter', async ()=>{
+            mockPermissionService.findUserBranches.mockResolvedValue([]);
+            await controller.getUserBranches('user-1');
+            expect(mockPermissionService.findUserBranches).toHaveBeenCalledWith('user-1', undefined);
+        });
+    });
+});

package/cjs/controllers/user.controller.spec.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _usercontroller = require("./user.controller");
+function buildUser(overrides = {}) {
+    return {
+        id: 'user-1',
+        name: 'Test User',
+        email: 'test@example.com',
+        phone: null,
+        isActive: true,
+        readOnly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('UserController', ()=>{
+    let controller;
+    let mockUserService;
+    beforeEach(()=>{
+        mockUserService = {
+            insert: jest.fn(),
+            insertMany: jest.fn(),
+            findById: jest.fn(),
+            findByIds: jest.fn(),
+            update: jest.fn(),
+            updateMany: jest.fn(),
+            bulkUpsert: jest.fn(),
+            getAll: jest.fn(),
+            delete: jest.fn(),
+            getProfileWithExtras: jest.fn(),
+            verifyEmail: jest.fn(),
+            verifyPhone: jest.fn(),
+            updateStatus: jest.fn(),
+            profile: jest.fn(),
+            getProfileSections: jest.fn(),
+            getProfileSectionData: jest.fn(),
+            updateProfileSection: jest.fn(),
+            getProfileCompletion: jest.fn()
+        };
+        controller = new _usercontroller.UserController(mockUserService);
+    });
+    describe('insert', ()=>{
+        it('creates a user and returns the mapped response', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockUserService.insert.mockResolvedValue(buildUser());
+            const result = await controller.insert({
+                name: 'Test User',
+                email: 'test@example.com',
+                password: 'Password1!'
+            }, user);
+            expect(mockUserService.insert).toHaveBeenCalledWith({
+                name: 'Test User',
+                email: 'test@example.com',
+                password: 'Password1!'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'user-1'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates users and maps the response list', async ()=>{
+            mockUserService.getAll.mockResolvedValue({
+                data: [
+                    buildUser()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, (0, _loggedusermock.buildMockUser)(), '');
+            expect(mockUserService.getAll).toHaveBeenCalledWith('', {}, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toHaveLength(1);
+        });
+    });
+    describe('getProfileWithExtras', ()=>{
+        it('returns the enriched profile payload', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockUserService.getProfileWithExtras.mockResolvedValue({
+                ...buildUser(),
+                completionPercentage: 80
+            });
+            const result = await controller.getProfileWithExtras('user-1', user);
+            expect(mockUserService.getProfileWithExtras).toHaveBeenCalledWith('user-1', user);
+            expect(result).toEqual({
+                success: true,
+                message: 'Profile extras retrieved successfully',
+                messageKey: expect.any(String),
+                data: expect.objectContaining({
+                    completionPercentage: 80
+                })
+            });
+        });
+    });
+    describe('verifyEmail', ()=>{
+        it('verifies the email and returns a success message', async ()=>{
+            mockUserService.verifyEmail.mockResolvedValue(undefined);
+            const result = await controller.verifyEmail('user-1');
+            expect(mockUserService.verifyEmail).toHaveBeenCalledWith('user-1');
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('verifyPhone', ()=>{
+        it('verifies the phone and returns a success message', async ()=>{
+            mockUserService.verifyPhone.mockResolvedValue(undefined);
+            const result = await controller.verifyPhone('user-1');
+            expect(mockUserService.verifyPhone).toHaveBeenCalledWith('user-1');
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('updateStatus', ()=>{
+        it('updates the active status for the given user', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockUserService.updateStatus.mockResolvedValue(undefined);
+            const result = await controller.updateStatus('user-1', false, user);
+            expect(mockUserService.updateStatus).toHaveBeenCalledWith('user-1', false, user);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('profile', ()=>{
+        it('updates the current user profile and returns the data', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockUserService.profile.mockResolvedValue('user-1');
+            const result = await controller.profile({
+                id: 'user-1',
+                name: 'New Name'
+            }, user);
+            expect(mockUserService.profile).toHaveBeenCalledWith({
+                id: 'user-1',
+                name: 'New Name'
+            }, user);
+            expect(result).toEqual({
+                success: true,
+                message: 'Profile updated successfully',
+                messageKey: expect.any(String),
+                data: 'user-1'
+            });
+        });
+    });
+    describe('getProfileSections', ()=>{
+        it('returns the profile section definitions', async ()=>{
+            mockUserService.getProfileSections.mockResolvedValue([
+                {
+                    id: 's1',
+                    name: 'Basic',
+                    order: 1
+                }
+            ]);
+            const result = await controller.getProfileSections();
+            expect(result.data).toEqual([
+                {
+                    id: 's1',
+                    name: 'Basic',
+                    order: 1
+                }
+            ]);
+        });
+    });
+    describe('getProfileSectionData', ()=>{
+        it('returns data for the requested section', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockUserService.getProfileSectionData.mockResolvedValue({
+                sectionId: 's1',
+                data: {
+                    foo: 'bar'
+                },
+                isComplete: true
+            });
+            const result = await controller.getProfileSectionData('user-1', 's1', user);
+            expect(mockUserService.getProfileSectionData).toHaveBeenCalledWith('user-1', 's1', user);
+            expect(result.data).toEqual(expect.objectContaining({
+                sectionId: 's1',
+                isComplete: true
+            }));
+        });
+    });
+    describe('updateProfileSection', ()=>{
+        it('updates the requested section', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockUserService.updateProfileSection.mockResolvedValue(undefined);
+            const result = await controller.updateProfileSection('user-1', 's1', {
+                foo: 'bar'
+            }, user);
+            expect(mockUserService.updateProfileSection).toHaveBeenCalledWith('user-1', 's1', {
+                foo: 'bar'
+            }, user);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('getProfileCompletion', ()=>{
+        it('returns the completion percentage', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockUserService.getProfileCompletion.mockResolvedValue(42);
+            const result = await controller.getProfileCompletion('user-1', user);
+            expect(mockUserService.getProfileCompletion).toHaveBeenCalledWith('user-1', user);
+            expect(result.data).toEqual({
+                completionPercentage: 42
+            });
+        });
+    });
+});

package/cjs/docs/auth-swagger.config.spec.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _authswaggerconfig = require("./auth-swagger.config");
+describe('authSwaggerConfig', ()=>{
+    it('should default to both features enabled and single-database mode when no config is given', ()=>{
+        const config = (0, _authswaggerconfig.authSwaggerConfig)();
+        expect(config.title).toBe('Auth API');
+        expect(config.path).toBe('api/docs/auth');
+        expect(config.bearerAuth).toBe(true);
+        expect(config.excludeTags).toEqual([]);
+        expect(config.excludeSchemaProperties).toBeUndefined();
+        expect(config.excludeExamples).toBeUndefined();
+        expect(config.excludePaths).toBeUndefined();
+        expect(config.description).not.toContain('Multi-Tenant Mode');
+    });
+    it('should exclude company-related tags, schema properties, and examples when the company feature is off', ()=>{
+        const config = (0, _authswaggerconfig.authSwaggerConfig)({
+            enableCompanyFeature: false,
+            databaseMode: 'single'
+        });
+        expect(config.excludeTags).toEqual(expect.arrayContaining([
+            'Companies',
+            'Branches',
+            'User Permissions',
+            'Company Selection'
+        ]));
+        expect(config.excludeSchemaProperties).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                schemaName: 'RegistrationDto'
+            })
+        ]));
+        expect(config.excludeExamples).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                pathPattern: '/auth/login',
+                examples: [
+                    'loginSuccessWithCompany',
+                    'companySelection'
+                ]
+            })
+        ]));
+        // Email verification is still enabled by default, so its paths must not be excluded
+        expect(config.excludePaths).toBeUndefined();
+    });
+    it('should exclude email-verification paths, schema properties, and examples when disabled', ()=>{
+        const config = (0, _authswaggerconfig.authSwaggerConfig)({
+            enableEmailVerification: false
+        });
+        expect(config.excludePaths).toEqual([
+            '/auth/forgot-password',
+            '/auth/reset-password',
+            '/auth/resend-verification',
+            '/auth/verify-email'
+        ]);
+        expect(config.excludeSchemaProperties).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                schemaName: 'LoginResponseRequiresEmailVerificationDto'
+            })
+        ]));
+        expect(config.excludeExamples).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                pathPattern: '/auth/login',
+                examples: [
+                    'emailVerification'
+                ]
+            })
+        ]));
+        // Company feature is still enabled by default, so its tags must not be excluded
+        expect(config.excludeTags).toEqual([]);
+    });
+    it('should merge exclusions from both features when both are disabled', ()=>{
+        const config = (0, _authswaggerconfig.authSwaggerConfig)({
+            enableCompanyFeature: false,
+            enableEmailVerification: false
+        });
+        expect(config.excludeTags?.length).toBeGreaterThan(0);
+        expect(config.excludePaths?.length).toBeGreaterThan(0);
+        // Both feature's schema exclusions should be present together
+        const schemaNames = config.excludeSchemaProperties?.map((e)=>e.schemaName) ?? [];
+        expect(schemaNames).toContain('RegistrationDto');
+        expect(schemaNames).toContain('LoginResponseRequiresEmailVerificationDto');
+        // Both feature's example exclusions merge onto the same /auth/login path
+        const loginExclusions = config.excludeExamples?.filter((e)=>e.pathPattern === '/auth/login');
+        expect(loginExclusions).toHaveLength(2);
+    });
+    it('should mention multi-tenant mode in the description only for multi-tenant database mode', ()=>{
+        const multiTenant = (0, _authswaggerconfig.authSwaggerConfig)({
+            databaseMode: 'multi-tenant'
+        });
+        const single = (0, _authswaggerconfig.authSwaggerConfig)({
+            databaseMode: 'single'
+        });
+        expect(multiTenant.description).toContain('Multi-Tenant Mode');
+        expect(single.description).not.toContain('Multi-Tenant Mode');
+    });
+    it('should describe the multi-company login flow only when the company feature is enabled', ()=>{
+        const withCompany = (0, _authswaggerconfig.authSwaggerConfig)({
+            enableCompanyFeature: true
+        });
+        const withoutCompany = (0, _authswaggerconfig.authSwaggerConfig)({
+            enableCompanyFeature: false
+        });
+        expect(withCompany.description).toContain('Multi-Company Login');
+        expect(withCompany.description).toContain('/auth/switch-company');
+        expect(withoutCompany.description).not.toContain('Multi-Company Login');
+        expect(withoutCompany.description).not.toContain('/auth/switch-company');
+    });
+    it('should describe email verification endpoints only when enabled', ()=>{
+        const withVerification = (0, _authswaggerconfig.authSwaggerConfig)({
+            enableEmailVerification: true
+        });
+        const withoutVerification = (0, _authswaggerconfig.authSwaggerConfig)({
+            enableEmailVerification: false
+        });
+        expect(withVerification.description).toContain('/auth/forgot-password');
+        expect(withoutVerification.description).not.toContain('### Email Verification Endpoints');
+    });
+    it('should list company administration endpoints only when the company feature is enabled', ()=>{
+        const withCompany = (0, _authswaggerconfig.authSwaggerConfig)({
+            enableCompanyFeature: true
+        });
+        const withoutCompany = (0, _authswaggerconfig.authSwaggerConfig)({
+            enableCompanyFeature: false
+        });
+        expect(withCompany.description).toContain('/administration/company/*');
+        expect(withoutCompany.description).not.toContain('/administration/company/*');
+        expect(withoutCompany.description).toContain('/administration/users/*');
+    });
+});

package/cjs/entities/index.spec.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _index = require("./index");
+const _appuserentity = require("./app-user.entity");
+const _usertokenentity = require("./user-token.entity");
+const _pendingregistrationentity = require("./pending-registration.entity");
+const _companyentity = require("./company.entity");
+const _companybranchentity = require("./company-branch.entity");
+const _usercompanypermissionentity = require("./user-company-permission.entity");
+describe('getAuthEntitiesByConfig', ()=>{
+    it('should always include the base entities', ()=>{
+        const entities = (0, _index.getAuthEntitiesByConfig)({
+            enableCompanyFeature: false,
+            enableEmailVerification: false
+        });
+        expect(entities).toEqual(expect.arrayContaining([
+            _appuserentity.AppUser,
+            _usertokenentity.UserToken
+        ]));
+    });
+    it('should include PendingRegistration when email verification is enabled', ()=>{
+        const entities = (0, _index.getAuthEntitiesByConfig)({
+            enableEmailVerification: true
+        });
+        expect(entities).toContain(_pendingregistrationentity.PendingRegistration);
+    });
+    it('should exclude PendingRegistration when email verification is disabled', ()=>{
+        const entities = (0, _index.getAuthEntitiesByConfig)({
+            enableEmailVerification: false
+        });
+        expect(entities).not.toContain(_pendingregistrationentity.PendingRegistration);
+    });
+    it('should include company entities when the company feature is enabled', ()=>{
+        const entities = (0, _index.getAuthEntitiesByConfig)({
+            enableCompanyFeature: true
+        });
+        expect(entities).toEqual(expect.arrayContaining([
+            _companyentity.Company,
+            _companybranchentity.CompanyBranch,
+            _usercompanypermissionentity.UserCompanyPermission
+        ]));
+    });
+    it('should exclude company entities when the company feature is disabled', ()=>{
+        const entities = (0, _index.getAuthEntitiesByConfig)({
+            enableCompanyFeature: false
+        });
+        expect(entities).not.toEqual(expect.arrayContaining([
+            _companyentity.Company
+        ]));
+    });
+    it('should default enableEmailVerification to true and enableCompanyFeature to false when omitted', ()=>{
+        const entities = (0, _index.getAuthEntitiesByConfig)({});
+        expect(entities).toContain(_pendingregistrationentity.PendingRegistration);
+        expect(entities).not.toContain(_companyentity.Company);
+    });
+    it('should include every entity group when both features are enabled', ()=>{
+        const entities = (0, _index.getAuthEntitiesByConfig)({
+            enableCompanyFeature: true,
+            enableEmailVerification: true
+        });
+        expect(entities).toHaveLength(6);
+        expect(entities).toEqual(expect.arrayContaining([
+            _appuserentity.AppUser,
+            _usertokenentity.UserToken,
+            _pendingregistrationentity.PendingRegistration,
+            _companyentity.Company,
+            _companybranchentity.CompanyBranch,
+            _usercompanypermissionentity.UserCompanyPermission
+        ]));
+    });
+});