@flusys/nestjs-auth 1.1.0-beta → 1.1.0

package/fesm/controllers/branch.controller.js

@@ -25,13 +25,56 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { createApiController } from '@flusys/nestjs-shared/classes';
+import { createApiController, BRANCH_PERMISSIONS } from '@flusys/nestjs-shared/classes';
 import { Controller, Inject } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
 import { CompanyBranchResponseDto, CreateCompanyBranchDto, UpdateCompanyBranchDto } from '../dtos/company-branch.dto';
 import { BranchService } from '../services/branch.service';
 export class BranchController extends createApiController(CreateCompanyBranchDto, UpdateCompanyBranchDto, CompanyBranchResponseDto, {
-    security: 'jwt'
+    security: {
+        insert: {
+            level: 'permission',
+            permissions: [
+                BRANCH_PERMISSIONS.CREATE
+            ]
+        },
+        insertMany: {
+            level: 'permission',
+            permissions: [
+                BRANCH_PERMISSIONS.CREATE
+            ]
+        },
+        getById: {
+            level: 'permission',
+            permissions: [
+                BRANCH_PERMISSIONS.READ
+            ]
+        },
+        getAll: {
+            level: 'permission',
+            permissions: [
+                BRANCH_PERMISSIONS.READ
+            ]
+        },
+        update: {
+            level: 'permission',
+            permissions: [
+                BRANCH_PERMISSIONS.UPDATE
+            ]
+        },
+        updateMany: {
+            level: 'permission',
+            permissions: [
+                BRANCH_PERMISSIONS.UPDATE
+            ]
+        },
+        delete: {
+            level: 'permission',
+            permissions: [
+                BRANCH_PERMISSIONS.DELETE
+            ]
+        }
+    }
 }) {
     constructor(branchService){
         super(branchService), _define_property(this, "branchService", void 0), this.branchService = branchService;

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

@@ -26,42 +26,35 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { CurrentUser } from '@flusys/nestjs-shared/decorators';
-import { Body, Controller, Get, HttpCode, HttpStatus, Inject, Param, Post, UseGuards, UseInterceptors } from '@nestjs/common';
+import { Body, Controller, HttpCode, HttpStatus, Inject, Post, UseGuards, UseInterceptors } from '@nestjs/common';
 import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { LoginResponseDto, SelectDto, SwitchCompanyDto } from '../dtos/authentication.dto';
 import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
 import { SetToken } from '../interceptors/set-token.interceptor';
 import { AuthenticationService } from '../services/authentication.service';
 export class CompanySelectionController {
-    /**
-   * Select Company & Branch
-   * Used after login when user needs to select company and branch
-   */ async select(dto) {
+    async select(dto) {
         return this.authService.select(dto.sessionId, dto.companyId, dto.branchId);
     }
-    /**
-   * Switch Company/Branch
-   * Used to switch company/branch after already logged in
-   */ async switchCompany(userId, dto) {
+    async switchCompany(userId, dto) {
         return this.authService.switchCompany(userId, dto.companyId, dto.branchId);
     }
-    /**
-   * Get user's companies
-   */ async getUserCompanies(userId) {
+    async getUserCompanies(userId) {
         const companies = await this.authService.getUserCompanies(userId);
         return {
-            companies
+            success: true,
+            message: 'User companies retrieved successfully',
+            data: companies
         };
     }
-    /**
-   * Get branches for a specific company
-   */ async getUserBranches(userId, companyId) {
+    async getUserBranches(userId, companyId) {
         const branches = await this.authService.getUserBranches(userId, companyId);
         return {
-            branches
+            success: true,
+            message: 'Company branches retrieved successfully',
+            data: branches
         };
     }
-    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
     constructor(authService){
         _define_property(this, "authService", void 0);
         this.authService = authService;
@@ -117,7 +110,8 @@ _ts_decorate([
 ], CompanySelectionController.prototype, "switchCompany", null);
 _ts_decorate([
     UseGuards(JwtAuthGuard),
-    Get('companies'),
+    Post('get-companies'),
+    HttpCode(HttpStatus.OK),
     ApiBearerAuth(),
     ApiOperation({
         summary: "Get user's available companies",
@@ -132,14 +126,27 @@ _ts_decorate([
 ], CompanySelectionController.prototype, "getUserCompanies", null);
 _ts_decorate([
     UseGuards(JwtAuthGuard),
-    Get('companies/:companyId/branches'),
+    Post('get-company-branches'),
+    HttpCode(HttpStatus.OK),
     ApiBearerAuth(),
     ApiOperation({
         summary: 'Get branches for a company',
         description: 'Get list of branches for a specific company that the user has access to'
     }),
+    ApiBody({
+        schema: {
+            properties: {
+                companyId: {
+                    type: 'string'
+                }
+            },
+            required: [
+                'companyId'
+            ]
+        }
+    }),
     _ts_param(0, CurrentUser('id')),
-    _ts_param(1, Param('companyId')),
+    _ts_param(1, Body('companyId')),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         String,

package/fesm/controllers/company.controller.js

@@ -25,13 +25,56 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { createApiController } from '@flusys/nestjs-shared/classes';
+import { createApiController, COMPANY_PERMISSIONS } from '@flusys/nestjs-shared/classes';
 import { Controller, Inject } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
 import { CompanyResponseDto, CreateCompanyDto, UpdateCompanyDto } from '../dtos/company.dto';
 import { CompanyService } from '../services/company.service';
 export class CompanyController extends createApiController(CreateCompanyDto, UpdateCompanyDto, CompanyResponseDto, {
-    security: 'jwt'
+    security: {
+        insert: {
+            level: 'permission',
+            permissions: [
+                COMPANY_PERMISSIONS.CREATE
+            ]
+        },
+        insertMany: {
+            level: 'permission',
+            permissions: [
+                COMPANY_PERMISSIONS.CREATE
+            ]
+        },
+        getById: {
+            level: 'permission',
+            permissions: [
+                COMPANY_PERMISSIONS.READ
+            ]
+        },
+        getAll: {
+            level: 'permission',
+            permissions: [
+                COMPANY_PERMISSIONS.READ
+            ]
+        },
+        update: {
+            level: 'permission',
+            permissions: [
+                COMPANY_PERMISSIONS.UPDATE
+            ]
+        },
+        updateMany: {
+            level: 'permission',
+            permissions: [
+                COMPANY_PERMISSIONS.UPDATE
+            ]
+        },
+        delete: {
+            level: 'permission',
+            permissions: [
+                COMPANY_PERMISSIONS.DELETE
+            ]
+        }
+    }
 }) {
     constructor(companyService){
         super(companyService), _define_property(this, "companyService", void 0), this.companyService = companyService;

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

@@ -0,0 +1,210 @@
+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 { 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 { ForgotPasswordDto, RegistrationResponseDto, 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('Email verification is not enabled for this tenant');
+        }
+    }
+    buildAuthUrl(req, path) {
+        const frontendUrl = this.authConfig.getFrontendUrl();
+        return frontendUrl ? `${frontendUrl}${path}` : `${req.protocol}://${req.get('host')}${path}`;
+    }
+    async forgotPassword(req, dto) {
+        this.ensureEmailVerificationEnabled();
+        return this.authEmailService.forgotPassword(dto.email, this.buildAuthUrl(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, this.buildAuthUrl(req, '/auth/verify-email'));
+    }
+    async verifyEmail(dto) {
+        this.ensureEmailVerificationEnabled();
+        const result = await this.authEmailService.verifyEmail(dto.token);
+        if (result.type === 'pending') {
+            return this.authService.createUserFromPendingRegistration(result.pending);
+        }
+        return {
+            success: true,
+            message: result.message
+        };
+    }
+    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,
+        type: MessageResponseDto
+    }),
+    ApiResponse({
+        status: 200,
+        type: RegistrationResponseDto
+    }),
+    _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/index.js

@@ -1,5 +1,6 @@
 export * from './authentication.controller';
 export * from './company-selection.controller';
+export * from './email-verification.controller';
 export * from './user.controller';
 export * from './company.controller';
 export * from './branch.controller';