@flusys/nestjs-auth 6.0.2 → 6.1.0

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

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _authenticationcontroller = require("./authentication.controller");
+describe('AuthenticationController', ()=>{
+    let controller;
+    let mockAuthService;
+    let mockAuthConfig;
+    beforeEach(()=>{
+        mockAuthService = {
+            login: jest.fn(),
+            register: jest.fn(),
+            refreshToken: jest.fn(),
+            getUserInfo: jest.fn(),
+            logout: jest.fn(),
+            changePassword: jest.fn()
+        };
+        mockAuthConfig = {
+            getRefreshTokenCookieName: jest.fn().mockReturnValue('fsn_refresh_token')
+        };
+        controller = new _authenticationcontroller.AuthenticationController(mockAuthService, mockAuthConfig);
+    });
+    describe('login', ()=>{
+        it('wraps a standard login response', async ()=>{
+            mockAuthService.login.mockResolvedValue({
+                accessToken: 'a',
+                refreshToken: 'r',
+                user: {
+                    id: 'u1',
+                    email: 'u@example.com'
+                }
+            });
+            const result = await controller.login({
+                email: 'u@example.com',
+                password: 'pw'
+            });
+            expect(result).toEqual(expect.objectContaining({
+                success: true,
+                data: expect.objectContaining({
+                    accessToken: 'a'
+                })
+            }));
+            expect(mockAuthService.login).toHaveBeenCalledWith('u@example.com', 'pw');
+        });
+        it('wraps a company-selection-required response', async ()=>{
+            mockAuthService.login.mockResolvedValue({
+                requiresSelection: true,
+                sessionId: 'sess-1'
+            });
+            const result = await controller.login({
+                email: 'u@example.com',
+                password: 'pw'
+            });
+            expect(result.message).toBe('Company selection required');
+            expect(result.data).toEqual(expect.objectContaining({
+                requiresSelection: true
+            }));
+        });
+        it('wraps an email-verification-required response', async ()=>{
+            mockAuthService.login.mockResolvedValue({
+                requiresEmailVerification: true,
+                email: 'u@example.com'
+            });
+            const result = await controller.login({
+                email: 'u@example.com',
+                password: 'pw'
+            });
+            expect(result.message).toBe('Email verification required');
+            expect(result.data).toEqual(expect.objectContaining({
+                requiresEmailVerification: true
+            }));
+        });
+        it('propagates errors thrown by the service', async ()=>{
+            mockAuthService.login.mockRejectedValue(new _common.UnauthorizedException('bad creds'));
+            await expect(controller.login({
+                email: 'u@example.com',
+                password: 'wrong'
+            })).rejects.toThrow(_common.UnauthorizedException);
+        });
+    });
+    describe('register', ()=>{
+        it('reports success message when registration completes without verification', async ()=>{
+            mockAuthService.register.mockResolvedValue({
+                accessToken: 'a',
+                user: {
+                    id: 'u1'
+                },
+                requiresEmailVerification: false
+            });
+            const req = {
+                headers: {},
+                get: jest.fn((h)=>h === 'host' ? 'app.example.com' : undefined),
+                protocol: 'https'
+            };
+            const result = await controller.register(req, {
+                name: 'New',
+                email: 'new@example.com',
+                password: 'Password1!'
+            });
+            expect(result.message).toBe('Registration successful');
+            expect(result.success).toBe(true);
+        });
+        it('reports verification-sent message when email verification is required', async ()=>{
+            mockAuthService.register.mockResolvedValue({
+                requiresEmailVerification: true,
+                user: {
+                    id: 'u1'
+                }
+            });
+            const req = {
+                headers: {},
+                get: jest.fn((h)=>h === 'host' ? 'app.example.com' : undefined),
+                protocol: 'https'
+            };
+            const result = await controller.register(req, {
+                name: 'New',
+                email: 'new@example.com',
+                password: 'Password1!'
+            });
+            expect(result.message).toBe('Verification email sent');
+        });
+    });
+    describe('refreshToken', ()=>{
+        it('reads the refresh token from the cookie first', async ()=>{
+            mockAuthService.refreshToken.mockResolvedValue({
+                accessToken: 'new-token'
+            });
+            const req = {
+                cookies: {
+                    fsn_refresh_token: 'cookie-token'
+                }
+            };
+            await controller.refreshToken(req, {
+                refreshToken: 'body-token'
+            });
+            expect(mockAuthService.refreshToken).toHaveBeenCalledWith('cookie-token');
+        });
+        it('falls back to the request body when no cookie is present', async ()=>{
+            mockAuthService.refreshToken.mockResolvedValue({
+                accessToken: 'new-token'
+            });
+            const req = {
+                cookies: {}
+            };
+            await controller.refreshToken(req, {
+                refreshToken: 'body-token'
+            });
+            expect(mockAuthService.refreshToken).toHaveBeenCalledWith('body-token');
+        });
+        it('throws UnauthorizedException when no refresh token is available', async ()=>{
+            const req = {
+                cookies: {}
+            };
+            await expect(controller.refreshToken(req, {})).rejects.toThrow(_common.UnauthorizedException);
+            expect(mockAuthService.refreshToken).not.toHaveBeenCalled();
+        });
+        it('uses the default cookie name when authConfig is unavailable', async ()=>{
+            controller = new _authenticationcontroller.AuthenticationController(mockAuthService, undefined);
+            mockAuthService.refreshToken.mockResolvedValue({
+                accessToken: 'new-token'
+            });
+            const req = {
+                cookies: {
+                    fsn_refresh_token: 'cookie-token'
+                }
+            };
+            await controller.refreshToken(req, {});
+            expect(mockAuthService.refreshToken).toHaveBeenCalledWith('cookie-token');
+        });
+    });
+    describe('getCurrentUser', ()=>{
+        it('delegates to authService.getUserInfo with the current user context', async ()=>{
+            mockAuthService.getUserInfo.mockResolvedValue({
+                user: {
+                    id: 'u1'
+                }
+            });
+            const user = (0, _loggedusermock.buildMockUser)();
+            const result = await controller.getCurrentUser(user);
+            expect(mockAuthService.getUserInfo).toHaveBeenCalledWith(user.id, user.companyId, user.branchId);
+            expect(result.data).toEqual({
+                user: {
+                    id: 'u1'
+                }
+            });
+        });
+    });
+    describe('logout', ()=>{
+        it('delegates to authService.logout and returns a success message', async ()=>{
+            const result = await controller.logout('user-1');
+            expect(mockAuthService.logout).toHaveBeenCalledWith('user-1');
+            expect(result).toEqual(expect.objectContaining({
+                success: true
+            }));
+        });
+    });
+    describe('changePassword', ()=>{
+        it('delegates to authService.changePassword', async ()=>{
+            const result = await controller.changePassword('user-1', {
+                currentPassword: 'old',
+                newPassword: 'New1!aaaa'
+            });
+            expect(mockAuthService.changePassword).toHaveBeenCalledWith('user-1', 'old', 'New1!aaaa');
+            expect(result).toEqual(expect.objectContaining({
+                success: true
+            }));
+        });
+        it('propagates errors from an invalid current password', async ()=>{
+            mockAuthService.changePassword.mockRejectedValue(new _common.UnauthorizedException());
+            await expect(controller.changePassword('user-1', {
+                currentPassword: 'wrong',
+                newPassword: 'New1!aaaa'
+            })).rejects.toThrow(_common.UnauthorizedException);
+        });
+    });
+});

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _branchcontroller = require("./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.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 = (0, _loggedusermock.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({}, (0, _loggedusermock.buildMockUser)(), 'main');
+            expect(mockBranchService.getAll).toHaveBeenCalledWith('main', {}, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockBranchService.update).toHaveBeenCalledWith({
+                id: 'branch-1',
+                name: 'Updated Branch'
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockBranchService.delete).toHaveBeenCalledWith({
+                id: [
+                    'branch-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.success).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _companyselectioncontroller = require("./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.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/cjs/controllers/company.controller.spec.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _companycontroller = require("./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.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 = (0, _loggedusermock.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({}, (0, _loggedusermock.buildMockUser)(), 'acme');
+            expect(mockCompanyService.getAll).toHaveBeenCalledWith('acme', {}, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockCompanyService.update).toHaveBeenCalledWith({
+                id: 'company-1',
+                name: 'Updated Co'
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockCompanyService.delete).toHaveBeenCalledWith({
+                id: [
+                    'company-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.success).toBe(true);
+        });
+    });
+});