@flusys/nestjs-auth 0.1.0-beta.3 → 1.1.0-beta

package/cjs/strategies/jwt.strategy.js

@@ -14,6 +14,7 @@ const _passport = require("@nestjs/passport");
 const _passportjwt = require("passport-jwt");
 const _authconfigservice = require("../services/auth-config.service");
 const _authdatasourceprovider = require("../services/auth-datasource.provider");
+const _authenticationservice = require("../services/authentication.service");
 const _userentity = require("../entities/user.entity");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -44,8 +45,9 @@ function _ts_metadata(k, v) {
 }
 let JwtStrategy = class JwtStrategy extends (0, _passport.PassportStrategy)(_passportjwt.Strategy, 'jwt') {
     async validate(_req, payload) {
-        // Resolve request-scoped AuthDataSourceProvider for this request
+        // Resolve request-scoped services for this request
         let userRepository = null;
+        let authService = null;
         try {
             const dataSourceProvider = await this.moduleRef.resolve(_authdatasourceprovider.AuthDataSourceProvider, undefined, {
                 strict: false
@@ -53,12 +55,23 @@ let JwtStrategy = class JwtStrategy extends (0, _passport.PassportStrategy)(_pas
             if (dataSourceProvider) {
                 userRepository = await dataSourceProvider.getRepository(_userentity.User);
             }
+            // Resolve AuthenticationService for token revocation check
+            authService = await this.moduleRef.resolve(_authenticationservice.AuthenticationService, undefined, {
+                strict: false
+            });
         } catch (error) {
             throw new _common.UnauthorizedException('Unable to access user data');
         }
         if (!userRepository) {
             throw new _common.UnauthorizedException('User repository not available');
         }
+        // Check if token is revoked (logged out)
+        if (authService && payload.iat) {
+            const isRevoked = await authService.isTokenRevoked(payload.id, payload.iat);
+            if (isRevoked) {
+                throw new _common.UnauthorizedException('Token has been revoked');
+            }
+        }
         // Find user and check if active
         const user = await userRepository.findOne({
             where: {

package/config/auth.constants.d.ts

@@ -1,2 +1,5 @@
 export declare const AUTH_MODULE_OPTIONS = "AUTH_MODULE_OPTIONS";
+export declare const USER_ENRICHER = "USER_ENRICHER";
+export declare const BCRYPT_SALT_ROUNDS = 12;
 export declare const SESSION_CACHE_PREFIX = "auth:session";
+export declare const TOKEN_REVOKED_PREFIX = "auth:revoked";

package/controllers/authentication.controller.d.ts

@@ -1,22 +1,26 @@
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { Request } from 'express';
-import { ChangePasswordDto, CompanySelectionResponseDto, LoginDto, LoginResponseDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto } from '../dtos/authentication.dto';
+import { ChangePasswordDto, CompanySelectionResponseDto, ForgotPasswordDto, LoginDto, LoginResponseDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
+import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
 import { AuthConfigService } from '../services/auth-config.service';
+import { AuthEmailService } from '../services/auth-email.service';
 import { AuthenticationService } from '../services/authentication.service';
 export declare class AuthenticationController {
     private readonly authService;
     private readonly authConfig?;
-    constructor(authService: AuthenticationService, authConfig?: AuthConfigService);
+    private readonly authEmailService?;
+    constructor(authService: AuthenticationService, authConfig?: AuthConfigService, authEmailService?: AuthEmailService);
+    private buildAuthUrl;
     login(loginDto: LoginDto): Promise<LoginResponseDto | CompanySelectionResponseDto>;
-    register(registrationDto: RegistrationDto): Promise<RegistrationResponseDto>;
+    register(req: Request, registrationDto: RegistrationDto): Promise<RegistrationResponseDto>;
     refreshToken(req: Request, refreshTokenDto: RefreshTokenDto): Promise<{
         accessToken: string;
     }>;
     getCurrentUser(user: ILoggedUserInfo): Promise<MeResponseDto>;
-    logout(userId: string): Promise<{
-        message: string;
-    }>;
-    changePassword(userId: string, dto: ChangePasswordDto): Promise<{
-        message: string;
-    }>;
+    logout(userId: string): Promise<MessageResponseDto>;
+    changePassword(userId: string, dto: ChangePasswordDto): Promise<MessageResponseDto>;
+    forgotPassword(req: Request, dto: ForgotPasswordDto): Promise<MessageResponseDto>;
+    resetPassword(dto: ResetPasswordDto): Promise<MessageResponseDto>;
+    resendVerification(req: Request, dto: ResendVerificationDto): Promise<MessageResponseDto>;
+    verifyEmail(dto: VerifyEmailDto): Promise<MessageResponseDto | RegistrationResponseDto>;
 }

package/controllers/user.controller.d.ts

@@ -1,5 +1,6 @@
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { CreateUserDto, UpdateUserDto, UserResponseDto } from '../dtos/user.dto';
+import { IUser } from '../interfaces/user.interface';
 import { UserService } from '../services/user.service';
 declare const UserController_base: abstract new (service: UserService) => {
     service: UserService;
@@ -14,6 +15,13 @@ declare const UserController_base: abstract new (service: UserService) => {
 export declare class UserController extends UserController_base {
     service: UserService;
     constructor(service: UserService);
+    getProfileWithExtras(id: string, user: ILoggedUserInfo): Promise<{
+        success: boolean;
+        data: {
+            user: IUser;
+            extras?: import("..").IProfileExtras;
+        };
+    }>;
     verifyEmail(id: string): Promise<{
         message: string;
     }>;
@@ -24,8 +32,27 @@ export declare class UserController extends UserController_base {
         message: string;
     }>;
     profile(dto: UpdateUserDto, user: ILoggedUserInfo): Promise<{
+        success: boolean;
         message: string;
         data: string;
     }>;
+    getProfileSections(): Promise<{
+        success: boolean;
+        data: import("..").IProfileSection[];
+    }>;
+    getProfileSectionData(id: string, sectionId: string, user: ILoggedUserInfo): Promise<{
+        success: boolean;
+        data: import("..").IProfileSectionData;
+    }>;
+    updateProfileSection(id: string, sectionId: string, data: Record<string, any>, user: ILoggedUserInfo): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getProfileCompletion(id: string, user: ILoggedUserInfo): Promise<{
+        success: boolean;
+        data: {
+            completionPercentage: number;
+        };
+    }>;
 }
 export {};

package/dtos/authentication.dto.d.ts

@@ -71,12 +71,13 @@ export declare class LoginResponseDto {
     companyFeatureEnabled?: boolean;
 }
 export declare class RegistrationResponseDto {
-    accessToken: string;
-    refreshToken: string;
+    accessToken?: string;
+    refreshToken?: string;
     user: UserInfoDto;
     company?: CompanyInfoDto;
     branch?: BranchInfoDto;
-    companyFeatureEnabled: boolean;
+    companyFeatureEnabled?: boolean;
+    requiresEmailVerification?: boolean;
 }
 export declare class MeResponseDto {
     user: UserInfoDto;
@@ -90,3 +91,20 @@ export declare class CompanySelectionResponseDto {
     user: UserInfoDto;
     companies: CompanyWithBranchesDto[];
 }
+export declare class LoginResponseRequiresEmailVerificationDto {
+    requiresEmailVerification: true;
+    email: string;
+    message: string;
+}
+export declare class ForgotPasswordDto {
+    email: string;
+}
+export declare class ResetPasswordDto {
+    token: string;
+    newPassword: string;
+}
+export declare class VerifyEmailDto {
+    token: string;
+}
+export declare class ResendVerificationDto extends ForgotPasswordDto {
+}

package/dtos/user.dto.d.ts

@@ -11,6 +11,7 @@ export declare class CreateUserDto {
     additionalFields?: Record<string, any>;
 }
 export declare class UpdateUserDto {
+    [key: string]: unknown;
     id: string;
     name?: string;
     phone?: string;

package/entities/index.d.ts

@@ -1,12 +1,16 @@
 export * from './company-branch.entity';
 export * from './company.entity';
+export * from './pending-registration.entity';
 export { PermissionType, UserCompanyPermission } from './user-company-permission.entity';
 export * from './user.entity';
+export * from './user-token.entity';
 import { CompanyBranch } from './company-branch.entity';
 import { Company } from './company.entity';
+import { PendingRegistration } from './pending-registration.entity';
 import { UserCompanyPermission } from './user-company-permission.entity';
 import { User } from './user.entity';
-export declare const CoreEntities: (typeof User)[];
+import { UserToken } from './user-token.entity';
+export declare const CoreEntities: (typeof PendingRegistration | typeof User | typeof UserToken)[];
 export declare const CompanyEntities: (typeof Company | typeof CompanyBranch | typeof UserCompanyPermission)[];
-export declare const AllEntities: (typeof Company | typeof CompanyBranch | typeof User | typeof UserCompanyPermission)[];
-export declare function getEntitiesByConfig(enableCompanyFeature: boolean): (typeof Company | typeof CompanyBranch | typeof User | typeof UserCompanyPermission)[];
+export declare const AllEntities: (typeof Company | typeof CompanyBranch | typeof PendingRegistration | typeof User | typeof UserCompanyPermission | typeof UserToken)[];
+export declare function getEntitiesByConfig(enableCompanyFeature: boolean): (typeof Company | typeof CompanyBranch | typeof PendingRegistration | typeof User | typeof UserCompanyPermission | typeof UserToken)[];

package/entities/pending-registration.entity.d.ts

@@ -0,0 +1,17 @@
+export declare class PendingRegistration {
+    id: string;
+    email: string;
+    name: string | null;
+    phone: string | null;
+    passwordHash: string;
+    token: string;
+    expiresAt: Date;
+    companyData: {
+        companySlug?: string;
+        branchSlug?: string;
+        newCompanyName?: string;
+        newCompanyPhone?: string;
+        newCompanyAddress?: string;
+    } | null;
+    createdAt: Date;
+}

package/entities/user-token.entity.d.ts

@@ -0,0 +1,15 @@
+export declare enum TokenType {
+    PASSWORD_RESET = "password_reset",
+    EMAIL_VERIFICATION = "email_verification",
+    EMAIL_CHANGE = "email_change"
+}
+export declare class UserToken {
+    id: string;
+    userId: string;
+    type: TokenType;
+    token: string;
+    expiresAt: Date;
+    usedAt: Date | null;
+    metadata: string | null;
+    createdAt: Date;
+}

package/fesm/config/auth.constants.js

@@ -1,8 +1,18 @@
-// =============================================================================
-// INJECTION TOKENS
-// =============================================================================
-/** Injection token for auth module options */ export const AUTH_MODULE_OPTIONS = 'AUTH_MODULE_OPTIONS';
-// =============================================================================
-// CACHE KEY PREFIXES (Auth-specific)
-// =============================================================================
-/** Cache key prefix for authentication sessions */ export const SESSION_CACHE_PREFIX = 'auth:session';
+// Injection Tokens
+export const AUTH_MODULE_OPTIONS = 'AUTH_MODULE_OPTIONS';
+/**
+ * User Enricher Provider Token
+ *
+ * Optional provider for extending user list and profile.
+ * Consuming apps can provide their own implementation.
+ *
+ * @example
+ * providers: [
+ *   { provide: USER_ENRICHER, useClass: MyUserEnricher },
+ * ]
+ */ export const USER_ENRICHER = 'USER_ENRICHER';
+// Security Configuration
+/** Bcrypt salt rounds (12 = ~250ms hashing time) */ export const BCRYPT_SALT_ROUNDS = 12;
+// Cache Key Prefixes
+export const SESSION_CACHE_PREFIX = 'auth:session';
+export const TOKEN_REVOKED_PREFIX = 'auth:revoked';

package/fesm/controllers/authentication.controller.js

@@ -31,43 +31,35 @@ import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { Body, Controller, Get, HttpCode, HttpStatus, Inject, Optional, Post, Req, UnauthorizedException, UseGuards, UseInterceptors } from '@nestjs/common';
 import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { Request } from 'express';
-import { ChangePasswordDto, CompanySelectionResponseDto, LoginDto, LoginResponseDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto } from '../dtos/authentication.dto';
+import { ChangePasswordDto, CompanySelectionResponseDto, ForgotPasswordDto, LoginDto, LoginResponseDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
+import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
 import { ClearToken } from '../interceptors/clear-token.interceptor';
 import { SetToken } from '../interceptors/set-token.interceptor';
 import { AuthConfigService } from '../services/auth-config.service';
+import { AuthEmailService } from '../services/auth-email.service';
 import { AuthenticationService } from '../services/authentication.service';
 export class AuthenticationController {
-    // ==========================================================================
-    // CORE ENDPOINTS (Always available)
-    // ==========================================================================
-    /**
-   * Login
-   * Returns either tokens directly or company/branch selection requirement
-   * Browser: refreshToken set in HTTP-only cookie, not in response body
-   * API/Mobile: refreshToken included in response body
-   */ async login(loginDto) {
+    /** Build auth URL for email links */ buildAuthUrl(req, path) {
+        const frontendUrl = this.authConfig?.getFrontendUrl();
+        return frontendUrl ? `${frontendUrl}${path}` : `${req.protocol}://${req.get('host')}${path}`;
+    }
+    // Core Endpoints
+    /** Login - Returns tokens or company/branch selection requirement */ async login(loginDto) {
         const result = await this.authService.login(loginDto.email, loginDto.password);
         if ('requiresSelection' in result) {
             return result;
         }
         return result;
     }
-    /**
-   * Register new user
-   * If company feature enabled, can optionally join/create company
-   * Browser: refreshToken set in HTTP-only cookie
-   */ async register(registrationDto) {
-        const result = await this.authService.register(registrationDto);
+    /** Register new user. If company feature enabled, can join/create company. */ async register(req, registrationDto) {
+        const verifyUrlBase = this.buildAuthUrl(req, '/auth/verify-email');
+        const result = await this.authService.register(registrationDto, verifyUrlBase);
         return {
             ...result,
             companyFeatureEnabled: this.authConfig?.isCompanyFeatureEnabled() ?? false
         };
     }
-    /**
-   * Refresh access token
-   * Browser: Gets refreshToken from HTTP-only cookie
-   * API/Mobile: Gets refreshToken from request body
-   */ async refreshToken(req, refreshTokenDto) {
+    /** Refresh access token. Browser uses HTTP-only cookie, API/Mobile uses request body. */ async refreshToken(req, refreshTokenDto) {
         // Get refresh token from cookie (browser) or body (API/mobile)
         const cookieName = this.authConfig?.getRefreshTokenCookieName() ?? 'fsn_refresh_token';
         const refreshToken = req.cookies?.[cookieName] || refreshTokenDto.refreshToken;
@@ -76,37 +68,80 @@ export class AuthenticationController {
         }
         return this.authService.refreshToken(refreshToken);
     }
-    /**
-   * Get current user info
-   * Returns only user, company, and branch data (no tokens)
-   * Uses existing access token from Authorization header
-   * Company/branch fields are automatically excluded from Swagger when company feature is disabled
-   */ async getCurrentUser(user) {
+    /** Get current user info. Returns user, company, and branch data (no tokens). */ async getCurrentUser(user) {
         return this.authService.getUserInfo(user.id, user.companyId, user.branchId);
     }
-    /**
-   * Logout
-   * Clears refresh token cookie for browsers
-   */ async logout(userId) {
+    /** Logout - Clears refresh token cookie for browsers */ async logout(userId) {
         await this.authService.logout(userId);
         return {
+            success: true,
             message: 'Logged out successfully'
         };
     }
-    /**
-   * Change password
-   */ async changePassword(userId, dto) {
+    /** Change password */ async changePassword(userId, dto) {
         await this.authService.changePassword(userId, dto.currentPassword, dto.newPassword);
         return {
+            success: true,
             message: 'Password changed successfully'
         };
     }
+    // Email Auth Endpoints
+    /** Forgot password - Request password reset email */ async forgotPassword(req, dto) {
+        if (!this.authEmailService) {
+            return {
+                success: false,
+                message: 'Email service is not configured'
+            };
+        }
+        return this.authEmailService.forgotPassword(dto.email, this.buildAuthUrl(req, '/auth/reset-password'));
+    }
+    /** Reset password - Reset password using token */ async resetPassword(dto) {
+        if (!this.authEmailService) {
+            return {
+                success: false,
+                message: 'Email service is not configured'
+            };
+        }
+        return this.authEmailService.resetPassword(dto.token, dto.newPassword);
+    }
+    /** Resend verification email - For unauthenticated users (handles both pending registration and existing users) */ async resendVerification(req, dto) {
+        if (!this.authEmailService) {
+            return {
+                success: false,
+                message: 'Email service is not configured'
+            };
+        }
+        return this.authEmailService.resendVerificationEmail(dto.email, this.buildAuthUrl(req, '/auth/verify-email'));
+    }
+    /** Verify email - Verify email using token. Handles both pending registration and existing user verification. */ async verifyEmail(dto) {
+        if (!this.authEmailService) {
+            return {
+                success: false,
+                message: 'Email service is not configured'
+            };
+        }
+        const result = await this.authEmailService.verifyEmail(dto.token);
+        if (result.type === 'pending') {
+            // Create user from pending registration
+            const registrationResult = await this.authService.createUserFromPendingRegistration(result.pending);
+            return {
+                ...registrationResult,
+                companyFeatureEnabled: this.authConfig?.isCompanyFeatureEnabled() ?? false
+            };
+        }
+        return {
+            success: true,
+            message: result.message
+        };
+    }
     // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
-    constructor(authService, authConfig){
+    constructor(authService, authConfig, authEmailService){
         _define_property(this, "authService", void 0);
         _define_property(this, "authConfig", void 0);
+        _define_property(this, "authEmailService", void 0);
         this.authService = authService;
         this.authConfig = authConfig;
+        this.authEmailService = authEmailService;
     }
 }
 _ts_decorate([
@@ -148,9 +183,11 @@ _ts_decorate([
         status: 201,
         type: RegistrationResponseDto
     }),
-    _ts_param(0, Body()),
+    _ts_param(0, Req()),
+    _ts_param(1, Body()),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
+        typeof Request === "undefined" ? Object : Request,
         typeof RegistrationDto === "undefined" ? Object : RegistrationDto
     ]),
     _ts_metadata("design:returntype", Promise)
@@ -200,6 +237,10 @@ _ts_decorate([
     ApiOperation({
         summary: 'Logout user'
     }),
+    ApiResponse({
+        status: 200,
+        type: MessageResponseDto
+    }),
     _ts_param(0, CurrentUser('id')),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
@@ -218,6 +259,10 @@ _ts_decorate([
     ApiBody({
         type: ChangePasswordDto
     }),
+    ApiResponse({
+        status: 200,
+        type: MessageResponseDto
+    }),
     _ts_param(0, CurrentUser('id')),
     _ts_param(1, Body()),
     _ts_metadata("design:type", Function),
@@ -227,15 +272,107 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", Promise)
 ], AuthenticationController.prototype, "changePassword", null);
+_ts_decorate([
+    Post('forgot-password'),
+    HttpCode(HttpStatus.OK),
+    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)
+], AuthenticationController.prototype, "forgotPassword", null);
+_ts_decorate([
+    Post('reset-password'),
+    HttpCode(HttpStatus.OK),
+    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)
+], AuthenticationController.prototype, "resetPassword", null);
+_ts_decorate([
+    Post('resend-verification'),
+    HttpCode(HttpStatus.OK),
+    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)
+], AuthenticationController.prototype, "resendVerification", null);
+_ts_decorate([
+    Post('verify-email'),
+    HttpCode(HttpStatus.OK),
+    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)
+], AuthenticationController.prototype, "verifyEmail", null);
 AuthenticationController = _ts_decorate([
     ApiTags('Authentication'),
     Controller('auth'),
     _ts_param(0, Inject(AuthenticationService)),
     _ts_param(1, Optional()),
     _ts_param(1, Inject(AuthConfigService)),
+    _ts_param(2, Optional()),
+    _ts_param(2, Inject(AuthEmailService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof AuthenticationService === "undefined" ? Object : AuthenticationService,
-        typeof AuthConfigService === "undefined" ? Object : AuthConfigService
+        typeof AuthConfigService === "undefined" ? Object : AuthConfigService,
+        typeof AuthEmailService === "undefined" ? Object : AuthEmailService
     ])
 ], AuthenticationController);

package/fesm/controllers/branch.controller.js

@@ -26,21 +26,20 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { createApiController } from '@flusys/nestjs-shared/classes';
-import { Controller, Inject, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { Controller, Inject } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
 import { CompanyBranchResponseDto, CreateCompanyBranchDto, UpdateCompanyBranchDto } from '../dtos/company-branch.dto';
-import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
 import { BranchService } from '../services/branch.service';
-export class BranchController extends createApiController(CreateCompanyBranchDto, UpdateCompanyBranchDto, CompanyBranchResponseDto) {
+export class BranchController extends createApiController(CreateCompanyBranchDto, UpdateCompanyBranchDto, CompanyBranchResponseDto, {
+    security: 'jwt'
+}) {
     constructor(branchService){
         super(branchService), _define_property(this, "branchService", void 0), this.branchService = branchService;
     }
 }
 BranchController = _ts_decorate([
     ApiTags('Branches'),
-    ApiBearerAuth(),
     Controller('administration/branch'),
-    UseGuards(JwtAuthGuard),
     _ts_param(0, Inject(BranchService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [

package/fesm/controllers/company.controller.js

@@ -26,21 +26,20 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { createApiController } from '@flusys/nestjs-shared/classes';
-import { Controller, Inject, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { Controller, Inject } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
 import { CompanyResponseDto, CreateCompanyDto, UpdateCompanyDto } from '../dtos/company.dto';
-import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
 import { CompanyService } from '../services/company.service';
-export class CompanyController extends createApiController(CreateCompanyDto, UpdateCompanyDto, CompanyResponseDto) {
+export class CompanyController extends createApiController(CreateCompanyDto, UpdateCompanyDto, CompanyResponseDto, {
+    security: 'jwt'
+}) {
     constructor(companyService){
         super(companyService), _define_property(this, "companyService", void 0), this.companyService = companyService;
     }
 }
 CompanyController = _ts_decorate([
     ApiTags('Companies'),
-    ApiBearerAuth(),
     Controller('administration/company'),
-    UseGuards(JwtAuthGuard),
     _ts_param(0, Inject(CompanyService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [