@flusys/nestjs-auth 6.0.1 → 6.1.0

package/fesm/controllers/branch.controller.spec.js

@@ -0,0 +1,130 @@
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { BranchController } from './branch.controller';
+function buildBranch(overrides = {}) {
+    return {
+        id: 'branch-1',
+        name: 'Main Branch',
+        slug: 'main-branch',
+        companyId: 'company-1',
+        parentId: null,
+        logoId: null,
+        address: null,
+        phone: null,
+        email: null,
+        serial: null,
+        isActive: true,
+        readOnly: false,
+        additionalFields: null,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('BranchController', ()=>{
+    let controller;
+    let mockBranchService;
+    beforeEach(()=>{
+        mockBranchService = {
+            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()
+        };
+        controller = new BranchController(mockBranchService);
+    });
+    it('wires the injected service onto the generated controller base', ()=>{
+        expect(controller.branchService).toBe(mockBranchService);
+        expect(controller.service).toBe(mockBranchService);
+    });
+    describe('insert', ()=>{
+        it('creates a branch and returns the mapped response', async ()=>{
+            const user = buildMockUser();
+            const branch = buildBranch();
+            mockBranchService.insert.mockResolvedValue(branch);
+            const result = await controller.insert({
+                name: 'Main Branch',
+                slug: 'main-branch',
+                companyId: 'company-1'
+            }, user);
+            expect(mockBranchService.insert).toHaveBeenCalledWith({
+                name: 'Main Branch',
+                slug: 'main-branch',
+                companyId: 'company-1'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'branch-1',
+                slug: 'main-branch'
+            }));
+        });
+    });
+    describe('getById', ()=>{
+        it('retrieves a branch by id', async ()=>{
+            const branch = buildBranch();
+            mockBranchService.findById.mockResolvedValue(branch);
+            const result = await controller.getById('branch-1', {}, null);
+            expect(mockBranchService.findById).toHaveBeenCalledWith('branch-1', null, undefined);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'branch-1'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates branches and maps the response list', async ()=>{
+            mockBranchService.getAll.mockResolvedValue({
+                data: [
+                    buildBranch()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, buildMockUser(), 'main');
+            expect(mockBranchService.getAll).toHaveBeenCalledWith('main', {}, buildMockUser());
+            expect(result.data).toHaveLength(1);
+            expect(result.meta.total).toBe(1);
+        });
+    });
+    describe('update', ()=>{
+        it('updates a branch and returns the mapped response', async ()=>{
+            const branch = buildBranch({
+                name: 'Updated Branch'
+            });
+            mockBranchService.update.mockResolvedValue(branch);
+            const result = await controller.update({
+                id: 'branch-1',
+                name: 'Updated Branch'
+            }, buildMockUser());
+            expect(mockBranchService.update).toHaveBeenCalledWith({
+                id: 'branch-1',
+                name: 'Updated Branch'
+            }, buildMockUser());
+            expect(result.data).toEqual(expect.objectContaining({
+                name: 'Updated Branch'
+            }));
+        });
+    });
+    describe('delete', ()=>{
+        it('delegates soft-delete to the service', async ()=>{
+            mockBranchService.delete.mockResolvedValue({
+                count: 1
+            });
+            const result = await controller.delete({
+                id: [
+                    'branch-1'
+                ],
+                type: 'delete'
+            }, buildMockUser());
+            expect(mockBranchService.delete).toHaveBeenCalledWith({
+                id: [
+                    'branch-1'
+                ],
+                type: 'delete'
+            }, buildMockUser());
+            expect(result.success).toBe(true);
+        });
+    });
+});

package/fesm/controllers/company-selection.controller.spec.js

@@ -0,0 +1,80 @@
+import { CompanySelectionController } from './company-selection.controller';
+describe('CompanySelectionController', ()=>{
+    let controller;
+    let mockAuthService;
+    beforeEach(()=>{
+        mockAuthService = {
+            select: jest.fn(),
+            switchCompany: jest.fn(),
+            getUserCompanies: jest.fn(),
+            getUserBranches: jest.fn()
+        };
+        controller = new CompanySelectionController(mockAuthService);
+    });
+    describe('select', ()=>{
+        it('completes login with the selected company/branch', async ()=>{
+            mockAuthService.select.mockResolvedValue({
+                accessToken: 'a'
+            });
+            const result = await controller.select({
+                sessionId: 'sess-1',
+                companyId: 'company-1',
+                branchId: 'branch-1'
+            });
+            expect(mockAuthService.select).toHaveBeenCalledWith('sess-1', 'company-1', 'branch-1');
+            expect(result).toEqual(expect.objectContaining({
+                success: true,
+                data: {
+                    accessToken: 'a'
+                }
+            }));
+        });
+    });
+    describe('switchCompany', ()=>{
+        it('switches company for the authenticated user', async ()=>{
+            mockAuthService.switchCompany.mockResolvedValue({
+                accessToken: 'b'
+            });
+            const result = await controller.switchCompany('user-1', {
+                companyId: 'company-2',
+                branchId: 'branch-2'
+            });
+            expect(mockAuthService.switchCompany).toHaveBeenCalledWith('user-1', 'company-2', 'branch-2');
+            expect(result.data).toEqual({
+                accessToken: 'b'
+            });
+        });
+    });
+    describe('getUserCompanies', ()=>{
+        it('returns the companies the user has access to', async ()=>{
+            mockAuthService.getUserCompanies.mockResolvedValue([
+                {
+                    id: 'company-1'
+                }
+            ]);
+            const result = await controller.getUserCompanies('user-1');
+            expect(mockAuthService.getUserCompanies).toHaveBeenCalledWith('user-1');
+            expect(result.data).toEqual([
+                {
+                    id: 'company-1'
+                }
+            ]);
+        });
+    });
+    describe('getUserBranches', ()=>{
+        it('returns the branches for the given company', async ()=>{
+            mockAuthService.getUserBranches.mockResolvedValue([
+                {
+                    id: 'branch-1'
+                }
+            ]);
+            const result = await controller.getUserBranches('user-1', 'company-1');
+            expect(mockAuthService.getUserBranches).toHaveBeenCalledWith('user-1', 'company-1');
+            expect(result.data).toEqual([
+                {
+                    id: 'branch-1'
+                }
+            ]);
+        });
+    });
+});

package/fesm/controllers/company.controller.spec.js

@@ -0,0 +1,127 @@
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { CompanyController } from './company.controller';
+function buildCompany(overrides = {}) {
+    return {
+        id: 'company-1',
+        name: 'Acme Corporation',
+        slug: 'acme-corp',
+        logoId: null,
+        address: null,
+        phone: null,
+        email: null,
+        website: null,
+        serial: null,
+        isActive: true,
+        readOnly: false,
+        settings: null,
+        additionalFields: null,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('CompanyController', ()=>{
+    let controller;
+    let mockCompanyService;
+    beforeEach(()=>{
+        mockCompanyService = {
+            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()
+        };
+        controller = new CompanyController(mockCompanyService);
+    });
+    it('wires the injected service onto the generated controller base', ()=>{
+        expect(controller.companyService).toBe(mockCompanyService);
+        expect(controller.service).toBe(mockCompanyService);
+    });
+    describe('insert', ()=>{
+        it('creates a company and returns the mapped response', async ()=>{
+            const user = buildMockUser();
+            const company = buildCompany();
+            mockCompanyService.insert.mockResolvedValue(company);
+            const result = await controller.insert({
+                name: 'Acme Corporation',
+                slug: 'acme-corp'
+            }, user);
+            expect(mockCompanyService.insert).toHaveBeenCalledWith({
+                name: 'Acme Corporation',
+                slug: 'acme-corp'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'company-1',
+                slug: 'acme-corp'
+            }));
+        });
+    });
+    describe('getById', ()=>{
+        it('retrieves a company by id', async ()=>{
+            mockCompanyService.findById.mockResolvedValue(buildCompany());
+            const result = await controller.getById('company-1', {}, null);
+            expect(mockCompanyService.findById).toHaveBeenCalledWith('company-1', null, undefined);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'company-1'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates companies and maps the response list', async ()=>{
+            mockCompanyService.getAll.mockResolvedValue({
+                data: [
+                    buildCompany()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, buildMockUser(), 'acme');
+            expect(mockCompanyService.getAll).toHaveBeenCalledWith('acme', {}, buildMockUser());
+            expect(result.data).toHaveLength(1);
+            expect(result.meta.total).toBe(1);
+        });
+    });
+    describe('update', ()=>{
+        it('updates a company and returns the mapped response', async ()=>{
+            const company = buildCompany({
+                name: 'Updated Co'
+            });
+            mockCompanyService.update.mockResolvedValue(company);
+            const result = await controller.update({
+                id: 'company-1',
+                name: 'Updated Co'
+            }, buildMockUser());
+            expect(mockCompanyService.update).toHaveBeenCalledWith({
+                id: 'company-1',
+                name: 'Updated Co'
+            }, buildMockUser());
+            expect(result.data).toEqual(expect.objectContaining({
+                name: 'Updated Co'
+            }));
+        });
+    });
+    describe('delete', ()=>{
+        it('delegates soft-delete to the service', async ()=>{
+            mockCompanyService.delete.mockResolvedValue({
+                count: 1
+            });
+            const result = await controller.delete({
+                id: [
+                    'company-1'
+                ],
+                type: 'delete'
+            }, buildMockUser());
+            expect(mockCompanyService.delete).toHaveBeenCalledWith({
+                id: [
+                    'company-1'
+                ],
+                type: 'delete'
+            }, buildMockUser());
+            expect(result.success).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,138 @@
+import { BadRequestException } from '@nestjs/common';
+import { EmailVerificationController } from './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(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(BadRequestException);
+        });
+        it('rejects resetPassword', async ()=>{
+            await expect(controller.resetPassword({
+                token: 't',
+                newPassword: 'New1!aaaa'
+            })).rejects.toThrow(BadRequestException);
+        });
+        it('rejects resendVerification', async ()=>{
+            await expect(controller.resendVerification(buildRequest(), {
+                email: 'a@example.com'
+            })).rejects.toThrow(BadRequestException);
+        });
+        it('rejects verifyEmail', async ()=>{
+            await expect(controller.verifyEmail({
+                token: 't'
+            })).rejects.toThrow(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/fesm/controllers/user-permission.controller.spec.js

@@ -0,0 +1,134 @@
+import { UserPermissionController } from './user-permission.controller';
+import { PermissionType } from '../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(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', PermissionType.COMPANY);
+            expect(mockPermissionService.revokePermission).toHaveBeenCalledWith('user-1', 'company-2', 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', 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);
+        });
+    });
+});