@flusys/nestjs-auth 7.1.0 → 8.0.0

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

@@ -1,127 +0,0 @@
-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.js

@@ -1,214 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { buildFrontendUrl } from '@flusys/nestjs-shared';
-import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
-import { BadRequestException, Body, Controller, HttpCode, HttpStatus, Inject, Post, Req, UseInterceptors } from '@nestjs/common';
-import { ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { Throttle } from '@nestjs/throttler';
-import { Request } from 'express';
-import { AUTH_MESSAGES, EMAIL_VERIFICATION_MESSAGES } from '../config';
-import { ForgotPasswordDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
-import { SetToken } from '../interceptors/set-token.interceptor';
-import { AuthConfigService } from '../services/auth-config.service';
-import { AuthDataSourceProvider } from '../services/auth-datasource.provider';
-import { AuthEmailService } from '../services/auth-email.service';
-import { AuthenticationService } from '../services/authentication.service';
-export class EmailVerificationController {
-    ensureEmailVerificationEnabled() {
-        if (!this.dataSourceProvider.isEmailVerificationEnabled()) {
-            throw new BadRequestException({
-                message: 'Email verification is not enabled for this tenant',
-                messageKey: EMAIL_VERIFICATION_MESSAGES.VERIFICATION_NOT_ENABLED
-            });
-        }
-    }
-    async forgotPassword(req, dto) {
-        this.ensureEmailVerificationEnabled();
-        return this.authEmailService.forgotPassword(dto.email, buildFrontendUrl(req, '/auth/reset-password'));
-    }
-    async resetPassword(dto) {
-        this.ensureEmailVerificationEnabled();
-        return this.authEmailService.resetPassword(dto.token, dto.newPassword);
-    }
-    async resendVerification(req, dto) {
-        this.ensureEmailVerificationEnabled();
-        return this.authEmailService.resendVerificationEmail(dto.email, buildFrontendUrl(req, '/auth/verify-email'));
-    }
-    async verifyEmail(dto) {
-        this.ensureEmailVerificationEnabled();
-        const result = await this.authEmailService.verifyEmail(dto.token);
-        if (result.type === 'pending') {
-            const data = await this.authService.createUserFromPendingRegistration(result.pending);
-            return {
-                success: true,
-                message: 'Registration completed successfully',
-                messageKey: AUTH_MESSAGES.REGISTER_SUCCESS,
-                data
-            };
-        }
-        return {
-            success: true,
-            message: result.message,
-            messageKey: result.messageKey
-        };
-    }
-    constructor(authService, authEmailService, authConfig, dataSourceProvider){
-        _define_property(this, "authService", void 0);
-        _define_property(this, "authEmailService", void 0);
-        _define_property(this, "authConfig", void 0);
-        _define_property(this, "dataSourceProvider", void 0);
-        this.authService = authService;
-        this.authEmailService = authEmailService;
-        this.authConfig = authConfig;
-        this.dataSourceProvider = dataSourceProvider;
-    }
-}
-_ts_decorate([
-    Post('forgot-password'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 3,
-            ttl: 300000
-        }
-    }),
-    ApiOperation({
-        summary: 'Request password reset email'
-    }),
-    ApiBody({
-        type: ForgotPasswordDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Req()),
-    _ts_param(1, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Request === "undefined" ? Object : Request,
-        typeof ForgotPasswordDto === "undefined" ? Object : ForgotPasswordDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailVerificationController.prototype, "forgotPassword", null);
-_ts_decorate([
-    Post('reset-password'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 5,
-            ttl: 900000
-        }
-    }),
-    ApiOperation({
-        summary: 'Reset password using token'
-    }),
-    ApiBody({
-        type: ResetPasswordDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof ResetPasswordDto === "undefined" ? Object : ResetPasswordDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailVerificationController.prototype, "resetPassword", null);
-_ts_decorate([
-    Post('resend-verification'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 3,
-            ttl: 300000
-        }
-    }),
-    ApiOperation({
-        summary: 'Resend email verification link'
-    }),
-    ApiBody({
-        type: ResendVerificationDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Req()),
-    _ts_param(1, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Request === "undefined" ? Object : Request,
-        typeof ResendVerificationDto === "undefined" ? Object : ResendVerificationDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailVerificationController.prototype, "resendVerification", null);
-_ts_decorate([
-    Post('verify-email'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 10,
-            ttl: 60000
-        }
-    }),
-    UseInterceptors(SetToken),
-    ApiOperation({
-        summary: 'Verify email using token'
-    }),
-    ApiBody({
-        type: VerifyEmailDto
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Email verified or registration completed'
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof VerifyEmailDto === "undefined" ? Object : VerifyEmailDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailVerificationController.prototype, "verifyEmail", null);
-EmailVerificationController = _ts_decorate([
-    ApiTags('Authentication'),
-    Controller('auth'),
-    _ts_param(0, Inject(AuthenticationService)),
-    _ts_param(1, Inject(AuthEmailService)),
-    _ts_param(2, Inject(AuthConfigService)),
-    _ts_param(3, Inject(AuthDataSourceProvider)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof AuthenticationService === "undefined" ? Object : AuthenticationService,
-        typeof AuthEmailService === "undefined" ? Object : AuthEmailService,
-        typeof AuthConfigService === "undefined" ? Object : AuthConfigService,
-        typeof AuthDataSourceProvider === "undefined" ? Object : AuthDataSourceProvider
-    ])
-], EmailVerificationController);

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

@@ -1,138 +0,0 @@
-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/social-auth-config.controller.js

@@ -1,97 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { createApiController } from '@flusys/nestjs-shared/classes';
-import { SOCIAL_AUTH_CONFIG_PERMISSIONS } from '@flusys/nestjs-shared/constants';
-import { Controller, Inject } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
-import { CreateSocialAuthConfigDto, SocialAuthConfigResponseDto, UpdateSocialAuthConfigDto } from '../dtos/social-auth.dto';
-import { SocialAuthConfigService } from '../services/social-auth-config.service';
-export class SocialAuthConfigController extends createApiController(CreateSocialAuthConfigDto, UpdateSocialAuthConfigDto, SocialAuthConfigResponseDto, {
-    entityName: 'social.config',
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                SOCIAL_AUTH_CONFIG_PERMISSIONS.CREATE
-            ]
-        },
-        bulkUpsert: {
-            level: 'permission',
-            permissions: [
-                SOCIAL_AUTH_CONFIG_PERMISSIONS.CREATE,
-                SOCIAL_AUTH_CONFIG_PERMISSIONS.UPDATE
-            ],
-            operator: 'AND'
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                SOCIAL_AUTH_CONFIG_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                SOCIAL_AUTH_CONFIG_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                SOCIAL_AUTH_CONFIG_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                SOCIAL_AUTH_CONFIG_PERMISSIONS.DELETE
-            ]
-        }
-    },
-    enabledEndpoints: [
-        'insert',
-        'bulkUpsert',
-        'getById',
-        'getAll',
-        'update',
-        'delete'
-    ]
-}) {
-    constructor(socialAuthConfigService){
-        super(socialAuthConfigService), _define_property(this, "socialAuthConfigService", void 0), this.socialAuthConfigService = socialAuthConfigService;
-    }
-}
-SocialAuthConfigController = _ts_decorate([
-    ApiTags('Social Auth Config'),
-    Controller('auth/social-config'),
-    _ts_param(0, Inject(SocialAuthConfigService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof SocialAuthConfigService === "undefined" ? Object : SocialAuthConfigService
-    ])
-], SocialAuthConfigController);