@flusys/nestjs-auth 6.0.2 → 6.1.1

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

@@ -0,0 +1,200 @@
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { UserController } from './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(mockUserService);
+    });
+    describe('insert', ()=>{
+        it('creates a user and returns the mapped response', async ()=>{
+            const user = 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({}, buildMockUser(), '');
+            expect(mockUserService.getAll).toHaveBeenCalledWith('', {}, buildMockUser());
+            expect(result.data).toHaveLength(1);
+        });
+    });
+    describe('getProfileWithExtras', ()=>{
+        it('returns the enriched profile payload', async ()=>{
+            const user = 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 = 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 = 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 = 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 = 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 = 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/fesm/docs/auth-swagger.config.spec.js

@@ -0,0 +1,126 @@
+import { authSwaggerConfig } from './auth-swagger.config';
+describe('authSwaggerConfig', ()=>{
+    it('should default to both features enabled and single-database mode when no config is given', ()=>{
+        const config = 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 = 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 = 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 = 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 = authSwaggerConfig({
+            databaseMode: 'multi-tenant'
+        });
+        const single = 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 = authSwaggerConfig({
+            enableCompanyFeature: true
+        });
+        const withoutCompany = 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 = authSwaggerConfig({
+            enableEmailVerification: true
+        });
+        const withoutVerification = 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 = authSwaggerConfig({
+            enableCompanyFeature: true
+        });
+        const withoutCompany = authSwaggerConfig({
+            enableCompanyFeature: false
+        });
+        expect(withCompany.description).toContain('/administration/company/*');
+        expect(withoutCompany.description).not.toContain('/administration/company/*');
+        expect(withoutCompany.description).toContain('/administration/users/*');
+    });
+});

package/fesm/entities/index.spec.js

@@ -0,0 +1,69 @@
+import { getAuthEntitiesByConfig } from './index';
+import { AppUser } from './app-user.entity';
+import { UserToken } from './user-token.entity';
+import { PendingRegistration } from './pending-registration.entity';
+import { Company } from './company.entity';
+import { CompanyBranch } from './company-branch.entity';
+import { UserCompanyPermission } from './user-company-permission.entity';
+describe('getAuthEntitiesByConfig', ()=>{
+    it('should always include the base entities', ()=>{
+        const entities = getAuthEntitiesByConfig({
+            enableCompanyFeature: false,
+            enableEmailVerification: false
+        });
+        expect(entities).toEqual(expect.arrayContaining([
+            AppUser,
+            UserToken
+        ]));
+    });
+    it('should include PendingRegistration when email verification is enabled', ()=>{
+        const entities = getAuthEntitiesByConfig({
+            enableEmailVerification: true
+        });
+        expect(entities).toContain(PendingRegistration);
+    });
+    it('should exclude PendingRegistration when email verification is disabled', ()=>{
+        const entities = getAuthEntitiesByConfig({
+            enableEmailVerification: false
+        });
+        expect(entities).not.toContain(PendingRegistration);
+    });
+    it('should include company entities when the company feature is enabled', ()=>{
+        const entities = getAuthEntitiesByConfig({
+            enableCompanyFeature: true
+        });
+        expect(entities).toEqual(expect.arrayContaining([
+            Company,
+            CompanyBranch,
+            UserCompanyPermission
+        ]));
+    });
+    it('should exclude company entities when the company feature is disabled', ()=>{
+        const entities = getAuthEntitiesByConfig({
+            enableCompanyFeature: false
+        });
+        expect(entities).not.toEqual(expect.arrayContaining([
+            Company
+        ]));
+    });
+    it('should default enableEmailVerification to true and enableCompanyFeature to false when omitted', ()=>{
+        const entities = getAuthEntitiesByConfig({});
+        expect(entities).toContain(PendingRegistration);
+        expect(entities).not.toContain(Company);
+    });
+    it('should include every entity group when both features are enabled', ()=>{
+        const entities = getAuthEntitiesByConfig({
+            enableCompanyFeature: true,
+            enableEmailVerification: true
+        });
+        expect(entities).toHaveLength(6);
+        expect(entities).toEqual(expect.arrayContaining([
+            AppUser,
+            UserToken,
+            PendingRegistration,
+            Company,
+            CompanyBranch,
+            UserCompanyPermission
+        ]));
+    });
+});

package/fesm/helpers/auth-response.mapper.js

@@ -0,0 +1,25 @@
+export function toUserInfo(user) {
+    return {
+        id: user.id,
+        email: user.email,
+        name: user.name ?? undefined,
+        phone: user.phone ?? null,
+        profilePictureId: user.profilePictureId ?? null
+    };
+}
+export function toCompanyInfo(company) {
+    return {
+        id: company.id,
+        name: company.name,
+        slug: company.slug,
+        logoId: company.logoId ?? null
+    };
+}
+export function toBranchInfo(branch) {
+    return {
+        id: branch.id,
+        name: branch.name,
+        slug: branch.slug,
+        logoId: branch.logoId ?? null
+    };
+}

package/fesm/helpers/auth-response.mapper.spec.js

@@ -0,0 +1,135 @@
+import { toBranchInfo, toCompanyInfo, toUserInfo } from './auth-response.mapper';
+function buildUser(overrides = {}) {
+    return {
+        id: 'user-uuid-1',
+        email: 'user@example.com',
+        name: 'Test User',
+        phone: null,
+        profilePictureId: null,
+        isActive: true,
+        emailVerified: false,
+        phoneVerified: false,
+        lastLoginAt: null,
+        additionalFields: null,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        password: null,
+        ...overrides
+    };
+}
+function buildCompany(overrides = {}) {
+    return {
+        id: 'company-uuid-1',
+        name: 'Acme Corp',
+        slug: 'acme-corp',
+        logoId: null,
+        readOnly: false,
+        address: null,
+        phone: null,
+        email: null,
+        website: null,
+        serial: null,
+        isActive: true,
+        settings: null,
+        additionalFields: null,
+        branches: [],
+        ...overrides
+    };
+}
+function buildBranch(overrides = {}) {
+    return {
+        id: 'branch-uuid-1',
+        name: 'Main Branch',
+        slug: 'main-branch',
+        logoId: null,
+        readOnly: false,
+        address: null,
+        phone: null,
+        email: null,
+        serial: null,
+        isActive: true,
+        additionalFields: null,
+        parentId: null,
+        parent: null,
+        children: [],
+        companyId: 'company-uuid-1',
+        company: buildCompany(),
+        ...overrides
+    };
+}
+describe('auth-response.mapper', ()=>{
+    describe('toUserInfo', ()=>{
+        it('maps all user fields', ()=>{
+            const user = buildUser({
+                name: 'John Doe',
+                phone: '+123',
+                profilePictureId: 'pic-1'
+            });
+            const result = toUserInfo(user);
+            expect(result).toEqual({
+                id: 'user-uuid-1',
+                email: 'user@example.com',
+                name: 'John Doe',
+                phone: '+123',
+                profilePictureId: 'pic-1'
+            });
+        });
+        it('defaults name to undefined and nullable fields to null when absent', ()=>{
+            const user = buildUser({
+                name: null,
+                phone: null,
+                profilePictureId: null
+            });
+            const result = toUserInfo(user);
+            expect(result.name).toBeUndefined();
+            expect(result.phone).toBeNull();
+            expect(result.profilePictureId).toBeNull();
+        });
+    });
+    describe('toCompanyInfo', ()=>{
+        it('maps all company fields', ()=>{
+            const company = buildCompany({
+                logoId: 'logo-1'
+            });
+            const result = toCompanyInfo(company);
+            expect(result).toEqual({
+                id: 'company-uuid-1',
+                name: 'Acme Corp',
+                slug: 'acme-corp',
+                logoId: 'logo-1'
+            });
+        });
+        it('defaults logoId to null when absent', ()=>{
+            const company = buildCompany({
+                logoId: null
+            });
+            const result = toCompanyInfo(company);
+            expect(result.logoId).toBeNull();
+        });
+    });
+    describe('toBranchInfo', ()=>{
+        it('maps all branch fields', ()=>{
+            const branch = buildBranch({
+                logoId: 'logo-2'
+            });
+            const result = toBranchInfo(branch);
+            expect(result).toEqual({
+                id: 'branch-uuid-1',
+                name: 'Main Branch',
+                slug: 'main-branch',
+                logoId: 'logo-2'
+            });
+        });
+        it('defaults logoId to null when absent', ()=>{
+            const branch = buildBranch({
+                logoId: null
+            });
+            const result = toBranchInfo(branch);
+            expect(result.logoId).toBeNull();
+        });
+    });
+});

package/fesm/helpers/index.js

@@ -0,0 +1,2 @@
+export * from './auth-response.mapper';
+export * from './token.helper';

package/fesm/helpers/token.helper.js

@@ -0,0 +1,40 @@
+export function generateTokens(jwtService, authConfig, payload) {
+    const accessToken = jwtService.sign({
+        ...payload,
+        type: 'access'
+    }, {
+        secret: authConfig.getJwtSecret(),
+        expiresIn: authConfig.getJwtExpiration(),
+        algorithm: 'HS256'
+    });
+    const refreshToken = jwtService.sign({
+        ...payload,
+        type: 'refresh'
+    }, {
+        secret: authConfig.getRefreshTokenSecret(),
+        expiresIn: authConfig.getRefreshTokenExpiration(),
+        algorithm: 'HS256'
+    });
+    return {
+        accessToken,
+        refreshToken
+    };
+}
+export function parseExpiryToMs(expiry) {
+    const match = expiry.match(/^(\d+)([smhd])$/);
+    if (!match) return 7 * 24 * 60 * 60 * 1000;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch(unit){
+        case 's':
+            return value * 1000;
+        case 'm':
+            return value * 60 * 1000;
+        case 'h':
+            return value * 60 * 60 * 1000;
+        case 'd':
+            return value * 24 * 60 * 60 * 1000;
+        default:
+            return 7 * 24 * 60 * 60 * 1000;
+    }
+}

package/fesm/helpers/token.helper.spec.js

@@ -0,0 +1,82 @@
+import { generateTokens, parseExpiryToMs } from './token.helper';
+describe('token.helper', ()=>{
+    describe('generateTokens', ()=>{
+        let mockJwtService;
+        let mockAuthConfig;
+        beforeEach(()=>{
+            mockJwtService = {
+                sign: jest.fn()
+            };
+            mockAuthConfig = {
+                getJwtSecret: jest.fn().mockReturnValue('jwt-secret'),
+                getJwtExpiration: jest.fn().mockReturnValue('1h'),
+                getRefreshTokenSecret: jest.fn().mockReturnValue('refresh-secret'),
+                getRefreshTokenExpiration: jest.fn().mockReturnValue('7d')
+            };
+        });
+        it('signs an access token and a refresh token with distinct secrets', ()=>{
+            mockJwtService.sign.mockReturnValueOnce('access-token-value').mockReturnValueOnce('refresh-token-value');
+            const result = generateTokens(mockJwtService, mockAuthConfig, {
+                id: 'user-1',
+                email: 'user@example.com',
+                type: 'access'
+            });
+            expect(result).toEqual({
+                accessToken: 'access-token-value',
+                refreshToken: 'refresh-token-value'
+            });
+            expect(mockJwtService.sign).toHaveBeenNthCalledWith(1, expect.objectContaining({
+                id: 'user-1',
+                email: 'user@example.com',
+                type: 'access'
+            }), expect.objectContaining({
+                secret: 'jwt-secret',
+                expiresIn: '1h',
+                algorithm: 'HS256'
+            }));
+            expect(mockJwtService.sign).toHaveBeenNthCalledWith(2, expect.objectContaining({
+                id: 'user-1',
+                email: 'user@example.com',
+                type: 'refresh'
+            }), expect.objectContaining({
+                secret: 'refresh-secret',
+                expiresIn: '7d',
+                algorithm: 'HS256'
+            }));
+        });
+        it('includes companyId and branchId in the signed payload when provided', ()=>{
+            mockJwtService.sign.mockReturnValue('token');
+            generateTokens(mockJwtService, mockAuthConfig, {
+                id: 'user-1',
+                email: 'user@example.com',
+                type: 'access',
+                companyId: 'company-1',
+                branchId: 'branch-1'
+            });
+            expect(mockJwtService.sign).toHaveBeenCalledWith(expect.objectContaining({
+                companyId: 'company-1',
+                branchId: 'branch-1'
+            }), expect.anything());
+        });
+    });
+    describe('parseExpiryToMs', ()=>{
+        it('parses seconds', ()=>{
+            expect(parseExpiryToMs('30s')).toBe(30 * 1000);
+        });
+        it('parses minutes', ()=>{
+            expect(parseExpiryToMs('15m')).toBe(15 * 60 * 1000);
+        });
+        it('parses hours', ()=>{
+            expect(parseExpiryToMs('2h')).toBe(2 * 60 * 60 * 1000);
+        });
+        it('parses days', ()=>{
+            expect(parseExpiryToMs('7d')).toBe(7 * 24 * 60 * 60 * 1000);
+        });
+        it('falls back to 7 days for an unparsable value', ()=>{
+            expect(parseExpiryToMs('not-a-duration')).toBe(7 * 24 * 60 * 60 * 1000);
+        });
+        it('falls back to 7 days for an unknown unit', ()=>{
+            expect(parseExpiryToMs('5y')).toBe(7 * 24 * 60 * 60 * 1000);
+        });
+    });
+});