@flusys/nestjs-auth 1.0.0-beta → 1.0.0

package/fesm/validators/password.validator.js

@@ -0,0 +1,48 @@
+import { registerDecorator } from 'class-validator';
+/**
+ * Strong password validation decorator.
+ * Validates that passwords meet complexity requirements to prevent weak passwords.
+ *
+ * @example
+ * ```typescript
+ * @IsStrongPassword()
+ * password!: string;
+ *
+ * // With custom options
+ * @IsStrongPassword({ minLength: 12, requireSpecialChar: false })
+ * password!: string;
+ * ```
+ */ export function IsStrongPassword(options = {}, validationOptions) {
+    const { minLength = 8, maxLength = 128, requireUppercase = true, requireLowercase = true, requireNumber = true, requireSpecialChar = true } = options;
+    return function(object, propertyName) {
+        registerDecorator({
+            name: 'isStrongPassword',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate (value) {
+                    if (typeof value !== 'string') return false;
+                    const checks = [
+                        value.length >= minLength,
+                        value.length <= maxLength,
+                        !requireUppercase || /[A-Z]/.test(value),
+                        !requireLowercase || /[a-z]/.test(value),
+                        !requireNumber || /[0-9]/.test(value),
+                        !requireSpecialChar || /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?~`]/.test(value)
+                    ];
+                    return checks.every(Boolean);
+                },
+                defaultMessage (args) {
+                    const requirements = [];
+                    if (minLength > 0) requirements.push(`at least ${minLength} characters`);
+                    if (requireUppercase) requirements.push('one uppercase letter');
+                    if (requireLowercase) requirements.push('one lowercase letter');
+                    if (requireNumber) requirements.push('one number');
+                    if (requireSpecialChar) requirements.push('one special character (!@#$%^&*...)');
+                    return `Password must contain ${requirements.join(', ')}`;
+                }
+            }
+        });
+    };
+}

package/interceptors/clear-token.interceptor.d.ts

@@ -6,5 +6,4 @@ export declare class ClearToken implements NestInterceptor {
     constructor(authConfig?: AuthConfigService);
     private get cookieName();
     intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
-    private clearRefreshTokenCookie;
 }

package/interceptors/set-token.interceptor.d.ts

@@ -5,7 +5,7 @@ export declare class SetToken implements NestInterceptor {
     private readonly authConfig?;
     constructor(authConfig?: AuthConfigService);
     private get cookieName();
+    private get maxAgeMs();
     intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
-    private isBrowserRequest;
     private setRefreshTokenCookie;
 }

package/interfaces/auth-email-provider.interface.d.ts

@@ -0,0 +1,6 @@
+export interface IAuthEmailProvider {
+    sendPasswordResetEmail(email: string, token: string, resetUrl: string): Promise<void>;
+    sendVerificationEmail(email: string, token: string, verifyUrl: string): Promise<void>;
+    sendWelcomeEmail?(email: string, name: string): Promise<void>;
+}
+export declare const AUTH_EMAIL_PROVIDER = "AUTH_EMAIL_PROVIDER";

package/interfaces/auth-module-options.interface.d.ts

@@ -1,15 +1,17 @@
 import { IBootstrapAppConfig, IDataSourceServiceOptions, IDynamicModuleConfig, IModuleOptionsFactory } from '@flusys/nestjs-core';
-import { ModuleMetadata, Type } from '@nestjs/common';
+import { ModuleMetadata, Provider, Type } from '@nestjs/common';
 export interface IAuthModuleConfig extends IDataSourceServiceOptions {
     jwtSecret?: string;
     jwtExpiration?: string;
     refreshTokenSecret?: string;
     refreshTokenExpiration?: string;
     refreshTokenCookieName?: string;
+    frontendUrl?: string;
 }
 export interface AuthModuleOptions extends IDynamicModuleConfig {
     bootstrapAppConfig?: IBootstrapAppConfig;
     config?: IAuthModuleConfig;
+    providers?: Provider[];
 }
 export interface AuthOptionsFactory extends IModuleOptionsFactory<IAuthModuleConfig> {
     createAuthOptions(): Promise<IAuthModuleConfig> | IAuthModuleConfig;
@@ -21,4 +23,5 @@ export interface AuthModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'>,
     inject?: any[];
     useClass?: Type<AuthOptionsFactory>;
     useExisting?: Type<AuthOptionsFactory>;
+    providers?: Provider[];
 }

package/interfaces/authentication.interface.d.ts

@@ -22,7 +22,6 @@ export interface LoginResponse {
     user: IUserMini;
     company?: ICompanyMini;
     branch?: ICompanyBranchMini;
-    companyFeatureEnabled?: boolean;
 }
 export interface MeResponse {
     user: IUserMini;
@@ -33,14 +32,12 @@ export interface BranchForSelection {
     id: string;
     name: string;
     slug: string;
-    isActive: boolean;
     logoId?: string | null;
 }
 export interface CompanyWithBranches {
     id: string;
     name: string;
     slug: string;
-    isActive: boolean;
     logoId?: string | null;
     branches: BranchForSelection[];
 }
@@ -51,3 +48,16 @@ export interface LoginResponseRequiresSelection {
     user: IUserMini;
     companies: CompanyWithBranches[];
 }
+export interface RegistrationResponse {
+    accessToken?: string;
+    refreshToken?: string;
+    user: IUserMini;
+    company?: ICompanyMini;
+    branch?: ICompanyBranchMini;
+    requiresEmailVerification?: boolean;
+}
+export interface LoginResponseRequiresEmailVerification {
+    requiresEmailVerification: true;
+    email: string;
+    message: string;
+}

package/interfaces/index.d.ts

@@ -1,5 +1,7 @@
 export * from './authentication.interface';
+export * from './auth-email-provider.interface';
 export * from './company-branch.interface';
 export * from './company.interface';
 export * from './user.interface';
+export * from './user-enricher.interface';
 export * from './auth-module-options.interface';

package/interfaces/user-enricher.interface.d.ts

@@ -0,0 +1,64 @@
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { QueryRunner, SelectQueryBuilder } from 'typeorm';
+import { User } from '../entities/user.entity';
+import { IUser } from './user.interface';
+export interface IProfileSection {
+    id: string;
+    name: string;
+    order: number;
+    icon?: string;
+    required?: boolean;
+    hasFileUpload?: boolean;
+    editPermission?: string;
+}
+export interface IProfileSectionData {
+    sectionId: string;
+    data: Record<string, any>;
+    isComplete: boolean;
+    files?: IProfileFile[];
+}
+export interface IProfileFile {
+    field: string;
+    id: string;
+    name: string;
+    url?: string;
+    type?: string;
+}
+export interface IProfileExtras {
+    roles?: IProfileRole[];
+    actions?: IProfileAction[];
+    sections?: IProfileSectionData[];
+    completionPercentage?: number;
+}
+export interface IProfileRole {
+    id: string;
+    name: string;
+    description?: string | null;
+}
+export interface IProfileAction {
+    id: string;
+    name: string;
+    code: string;
+    description?: string | null;
+}
+export type IEnrichedUser = IUser & IProfileExtras;
+export interface IUserEnricher {
+    enrichListQuery?(query: SelectQueryBuilder<User>, user: ILoggedUserInfo | null): Promise<{
+        extraFields: string[];
+    }>;
+    enrichListItems?(users: IUser[], user: ILoggedUserInfo | null): Promise<IEnrichedUser[]>;
+    getProfileExtras?(userId: string, user: ILoggedUserInfo): Promise<IProfileExtras>;
+    updateProfileExtras?(userId: string, extras: Record<string, any>, queryRunner: QueryRunner): Promise<void>;
+    validateProfileExtras?(userId: string, extras: Record<string, any>, user: ILoggedUserInfo): Promise<void>;
+    getProfileSections?(): IProfileSection[];
+    getProfileSectionData?(userId: string, sectionId: string, user: ILoggedUserInfo): Promise<IProfileSectionData>;
+    updateProfileSection?(userId: string, sectionId: string, data: Record<string, any>, queryRunner: QueryRunner): Promise<void>;
+    handleSectionFileUpload?(userId: string, sectionId: string, field: string, fileInfo: {
+        name: string;
+        url: string;
+        size: number;
+        type: string;
+    }, queryRunner: QueryRunner): Promise<IProfileFile>;
+    handleSectionFileDelete?(userId: string, sectionId: string, field: string, fileId: string, queryRunner: QueryRunner): Promise<void>;
+    calculateProfileCompletion?(userId: string, user: ILoggedUserInfo): Promise<number>;
+}

package/interfaces/user.interface.d.ts

@@ -3,6 +3,7 @@ export interface IUserMini {
     id: string;
     email: string;
     name?: string;
+    phone?: string | null;
     profilePictureId?: string | null;
 }
 export interface IUser extends Identity {

package/modules/auth.module.d.ts

@@ -2,9 +2,12 @@ import { DynamicModule } from '@nestjs/common';
 import { AuthModuleAsyncOptions, AuthModuleOptions } from '../interfaces/auth-module-options.interface';
 export declare class AuthModule {
     static forRoot(options: AuthModuleOptions): DynamicModule;
-    static forRootAsync(asyncOptions: AuthModuleAsyncOptions): DynamicModule;
-    private static buildDynamicModule;
+    static forRootAsync(options: AuthModuleAsyncOptions): DynamicModule;
+    private static buildModule;
+    private static buildImports;
+    private static buildControllers;
+    private static buildProviders;
+    private static buildExports;
     private static createAsyncProviders;
-    private static getRepositoryProviders;
     static getEntities(enableCompanyFeature?: boolean): any[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-auth",
-  "version": "1.0.0-beta",
+  "version": "1.0.0",
   "description": "Authentication and authorization infrastructure for NestJS applications",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -84,14 +84,14 @@
     "bcrypt": "^5.0.0 || ^6.0.0",
     "class-transformer": "^0.5.0",
     "class-validator": "^0.14.0",
-    "nodemailer": "^6.0.0",
+    "nodemailer": "^7.0.0",
     "passport": "^0.7.0",
     "passport-jwt": "^4.0.0",
     "passport-local": "^1.0.0",
     "typeorm": "^0.3.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "1.0.0-beta",
-    "@flusys/nestjs-shared": "1.0.0-beta"
+    "@flusys/nestjs-core": "1.0.0",
+    "@flusys/nestjs-shared": "1.0.0"
   }
 }

package/services/auth-config.service.d.ts

@@ -1,8 +1,11 @@
-import { DatabaseMode, IDatabaseConfig, ITenantDatabaseConfig } from '@flusys/nestjs-core';
-import { AuthModuleOptions, IAuthModuleConfig } from '../interfaces/auth-module-options.interface';
-export declare class AuthConfigService {
+import { DatabaseMode } from '@flusys/nestjs-core';
+import { IModuleConfigService } from '@flusys/nestjs-shared/interfaces';
+import { AuthModuleOptions } from '../interfaces/auth-module-options.interface';
+export declare class AuthConfigService implements IModuleConfigService {
+    private readonly logger;
     private readonly options;
     private readonly config;
+    private refreshTokenSecretWarned;
     constructor(injectedOptions?: AuthModuleOptions);
     getDatabaseMode(): DatabaseMode;
     isMultiTenant(): boolean;
@@ -12,9 +15,5 @@ export declare class AuthConfigService {
     getRefreshTokenSecret(): string;
     getRefreshTokenExpiration(): string;
     getRefreshTokenCookieName(): string;
-    getDefaultDatabaseConfig(): IDatabaseConfig | undefined;
-    getTenantDefaultDatabaseConfig(): IDatabaseConfig | undefined;
-    getTenants(): ITenantDatabaseConfig[];
-    getOptions(): AuthModuleOptions;
-    getConfig(): IAuthModuleConfig;
+    getFrontendUrl(): string | undefined;
 }

package/services/auth-datasource.provider.d.ts

@@ -17,9 +17,7 @@ export declare class AuthDataSourceProvider extends MultiTenantDataSourceService
     protected getSingleDataSource(): Promise<DataSource>;
     protected getOrCreateTenantConnection(tenant: ITenantDatabaseConfig): Promise<DataSource>;
     private static buildParentOptions;
-    getEnableCompanyFeature(): boolean;
-    getEnableCompanyFeatureForTenant(tenant?: ITenantDatabaseConfig): boolean;
-    getEnableCompanyFeatureForCurrentTenant(): boolean;
-    getAuthEntities(enableCompanyFeature?: boolean): Promise<any[]>;
+    isCompanyFeatureEnabled(tenant?: ITenantDatabaseConfig): boolean;
+    getAuthEntities(): Promise<any[]>;
     protected createDataSourceFromConfig(config: IDatabaseConfig): Promise<DataSource>;
 }

package/services/auth-email.service.d.ts

@@ -0,0 +1,54 @@
+import { PendingRegistration } from '../entities/pending-registration.entity';
+import { IAuthEmailProvider } from '../interfaces';
+import { AuthDataSourceProvider } from './auth-datasource.provider';
+export declare class AuthEmailService {
+    private readonly dataSourceProvider?;
+    private readonly emailProvider?;
+    private readonly logger;
+    private readonly PASSWORD_RESET_EXPIRY;
+    private readonly EMAIL_VERIFICATION_EXPIRY;
+    constructor(dataSourceProvider?: AuthDataSourceProvider, emailProvider?: IAuthEmailProvider);
+    isEmailEnabled(): boolean;
+    private getRepository;
+    private generateToken;
+    private hashToken;
+    private getErrorMessage;
+    private assertEmailEnabled;
+    private sendVerificationEmailSafe;
+    private validateTokenNotExpiredOrUsed;
+    hasPendingRegistration(email: string): Promise<boolean>;
+    createPendingRegistration(data: {
+        email: string;
+        name?: string;
+        phone?: string;
+        password: string;
+        companyData?: PendingRegistration['companyData'];
+        verifyUrlBase: string;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    forgotPassword(email: string, resetUrlBase: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    resetPassword(token: string, newPassword: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    verifyEmail(token: string): Promise<{
+        type: 'pending';
+        pending: PendingRegistration;
+    } | {
+        type: 'verified';
+        message: string;
+    }>;
+    resendVerificationEmail(email: string, verifyUrlBase: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    cleanupExpired(): Promise<{
+        deletedTokens: number;
+        deletedPending: number;
+    }>;
+}

package/services/authentication.service.d.ts

@@ -1,14 +1,13 @@
+import { HybridCache } from '@flusys/nestjs-shared/classes';
 import { JwtService } from '@nestjs/jwt';
-import { Repository } from 'typeorm';
-import { AuthConfigService } from './auth-config.service';
-import { AuthDataSourceProvider } from './auth-datasource.provider';
 import { RegistrationDto } from '../dtos/authentication.dto';
-import { HybridCache } from '@flusys/nestjs-shared/classes';
-import { LoginResponse, LoginResponseRequiresSelection, MeResponse } from '../interfaces/authentication.interface';
 import { CompanyBranch } from '../entities/company-branch.entity';
 import { Company } from '../entities/company.entity';
-import { UserCompanyPermission } from '../entities/user-company-permission.entity';
-import { User } from '../entities/user.entity';
+import { PendingRegistration } from '../entities/pending-registration.entity';
+import { LoginResponse, LoginResponseRequiresEmailVerification, LoginResponseRequiresSelection, MeResponse, RegistrationResponse } from '../interfaces/authentication.interface';
+import { AuthConfigService } from './auth-config.service';
+import { AuthDataSourceProvider } from './auth-datasource.provider';
+import { AuthEmailService } from './auth-email.service';
 import { CompanySelectionSessionService } from './company-selection-session.service';
 export declare class AuthenticationService {
     private readonly jwtService;
@@ -16,23 +15,29 @@ export declare class AuthenticationService {
     private readonly cacheManager?;
     private readonly dataSourceProvider?;
     private readonly sessionService?;
-    private readonly injectedUserRepository?;
-    private readonly injectedPermissionRepository?;
-    private readonly injectedCompanyRepository?;
-    private readonly injectedBranchRepository?;
+    private readonly authEmailService?;
     private readonly logger;
-    constructor(jwtService: JwtService, authConfig: AuthConfigService, cacheManager?: HybridCache, dataSourceProvider?: AuthDataSourceProvider, sessionService?: CompanySelectionSessionService, injectedUserRepository?: Repository<User>, injectedPermissionRepository?: Repository<UserCompanyPermission>, injectedCompanyRepository?: Repository<Company>, injectedBranchRepository?: Repository<CompanyBranch>);
+    constructor(jwtService: JwtService, authConfig: AuthConfigService, cacheManager?: HybridCache, dataSourceProvider?: AuthDataSourceProvider, sessionService?: CompanySelectionSessionService, authEmailService?: AuthEmailService);
+    private isCompanyFeatureEnabled;
     private getUserRepository;
     private getPermissionRepository;
     private getCompanyRepository;
     private getBranchRepository;
-    login(email: string, password: string): Promise<LoginResponse | LoginResponseRequiresSelection>;
+    login(email: string, password: string): Promise<LoginResponse | LoginResponseRequiresSelection | LoginResponseRequiresEmailVerification>;
     private handleCompanyBasedLogin;
-    register(dto: RegistrationDto): Promise<LoginResponse>;
-    private handleCompanyRegistration;
-    private generateSlug;
+    register(dto: RegistrationDto, verifyUrlBase?: string): Promise<RegistrationResponse | {
+        requiresEmailVerification: true;
+        message: string;
+    }>;
+    private handleExistingUserCompanyRegistration;
+    private createUserDirectly;
+    createUserFromPendingRegistration(pending: PendingRegistration): Promise<RegistrationResponse>;
+    private processCompanyRegistration;
+    private findOrCreateCompanyAndBranch;
+    private assignUserPermissions;
     select(sessionId: string, companyId: string, branchId: string): Promise<LoginResponse>;
     switchCompany(userId: string, companyId: string, branchId: string): Promise<LoginResponse>;
+    private validateAndLoginWithCompany;
     refreshToken(refreshToken: string): Promise<{
         accessToken: string;
         refreshToken: string;
@@ -48,7 +53,13 @@ export declare class AuthenticationService {
     getUserInfo(userId: string, companyId?: string, branchId?: string): Promise<MeResponse>;
     private ensureCompanyFeatureEnabled;
     private validateUser;
+    private toUserInfo;
+    private toCompanyInfo;
+    private toBranchInfo;
+    private generateTokens;
     private generateLoginResponse;
     private generateLoginResponseWithCompany;
     private generateCompanySelectionResponse;
+    private generateRegistrationResponse;
+    private generateRegistrationResponseWithCompany;
 }

package/services/company-selection-session.service.d.ts

@@ -8,7 +8,7 @@ interface StoredSession {
 export declare class CompanySelectionSessionService {
     protected cacheManager: HybridCache;
     constructor(cacheManager: HybridCache);
-    createSession(userId: string, companyId?: string): Promise<string>;
+    createSession(userId: string): Promise<string>;
     getSession(sessionId: string): Promise<StoredSession | null>;
     consumeSession(sessionId: string): Promise<StoredSession | null>;
     deleteSession(sessionId: string): Promise<void>;

package/services/index.d.ts

@@ -1,4 +1,5 @@
 export * from './authentication.service';
+export * from './auth-email.service';
 export * from './company-selection-session.service';
 export * from './user.service';
 export * from './company.service';

package/services/user-permission.service.d.ts

@@ -1,16 +1,13 @@
-import { AssignBranchPermissionDto, AssignCompanyPermissionDto } from '../dtos/user-company-permission.dto';
-import { UserCompanyPermission } from '../entities/user-company-permission.entity';
+import { PermissionType, UserCompanyPermission } from '../entities/user-company-permission.entity';
 import { AuthDataSourceProvider } from './auth-datasource.provider';
 export declare class UserPermissionService {
     private readonly dataSourceProvider;
-    private readonly logger;
     private _repository;
     constructor(dataSourceProvider: AuthDataSourceProvider);
     private getRepository;
-    findUserCompanies(userId: string): Promise<UserCompanyPermission[]>;
-    assignUserToCompany(dto: AssignCompanyPermissionDto): Promise<void>;
-    revokeCompanyAccess(userId: string, companyId: string): Promise<void>;
-    findUserBranches(userId: string): Promise<UserCompanyPermission[]>;
-    assignUserToBranch(dto: AssignBranchPermissionDto): Promise<void>;
-    revokeBranchAccess(userId: string, branchId: string): Promise<void>;
+    findUserPermissions(userId: string, type: PermissionType): Promise<UserCompanyPermission[]>;
+    assignPermission(userId: string, targetId: string, type: PermissionType, metadata?: Record<string, any>): Promise<void>;
+    revokePermission(userId: string, targetId: string, type: PermissionType): Promise<void>;
+    findUserCompanies: (userId: string) => Promise<UserCompanyPermission[]>;
+    findUserBranches(userId: string, companyId?: string): Promise<UserCompanyPermission[]>;
 }

package/services/user.service.d.ts

@@ -6,23 +6,28 @@ import { AuthConfigService } from './auth-config.service';
 import { AuthDataSourceProvider } from './auth-datasource.provider';
 import { CreateUserDto, UpdateUserDto } from '../dtos/user.dto';
 import { IUser } from '../interfaces/user.interface';
+import { IEnrichedUser, IProfileExtras, IProfileSection, IProfileSectionData, IUserEnricher } from '../interfaces/user-enricher.interface';
 import { User } from '../entities/user.entity';
 export declare class UserService extends RequestScopedApiService<CreateUserDto, UpdateUserDto, IUser, User, Repository<User>> {
     protected cacheManager: HybridCache;
     protected utilsService: UtilsService;
     private readonly dataSourceProvider;
     private readonly authConfig;
+    private readonly userEnricher?;
     private permissionRepository?;
     private dataSource?;
-    constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: AuthDataSourceProvider, authConfig: AuthConfigService);
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: AuthDataSourceProvider, authConfig: AuthConfigService, userEnricher?: IUserEnricher);
     protected resolveEntity(): EntityTarget<User>;
     protected getDataSourceProvider(): AuthDataSourceProvider;
     protected ensureRepositoryInitialized(): Promise<void>;
+    private getUserForProfile;
     verifyEmail(id: string): Promise<void>;
     verifyPhone(id: string): Promise<void>;
     updateStatus(id: string, isActive: boolean, user?: ILoggedUserInfo | null): Promise<void>;
-    protected convertSingleDtoToEntity(dto: CreateUserDto | UpdateUserDto, user: any): Promise<User>;
+    protected convertSingleDtoToEntity(dto: CreateUserDto | UpdateUserDto, user: ILoggedUserInfo | null): Promise<User>;
     protected convertEntityToResponseDto(entity: User, isRaw: boolean): IUser;
+    private convertRawToResponseDto;
+    private convertEntityToDto;
     protected convertEntityListToResponseListDto(entities: User[], isRaw: boolean): IUser[];
     protected getGlobalSearchQuery(query: any, search: string, _user: any): Promise<{
         query: any;
@@ -33,5 +38,16 @@ export declare class UserService extends RequestScopedApiService<CreateUserDto,
         isRaw: boolean;
     }>;
     insert(dto: CreateUserDto, user: ILoggedUserInfo | null): Promise<IUser>;
-    profile(dto: UpdateUserDto, user: ILoggedUserInfo): Promise<string>;
+    getProfileWithExtras(userId: string, user: ILoggedUserInfo): Promise<{
+        user: IUser;
+        extras?: IProfileExtras;
+    }>;
+    getEnrichedList(users: IUser[], user: ILoggedUserInfo | null): Promise<IEnrichedUser[]>;
+    getProfileSections(): Promise<IProfileSection[]>;
+    getProfileSectionData(userId: string, sectionId: string, user: ILoggedUserInfo): Promise<IProfileSectionData | null>;
+    updateProfileSection(userId: string, sectionId: string, data: Record<string, any>, user: ILoggedUserInfo): Promise<void>;
+    getProfileCompletion(userId: string, user: ILoggedUserInfo): Promise<number>;
+    profile(dto: UpdateUserDto & {
+        extras?: Record<string, any>;
+    }, user: ILoggedUserInfo): Promise<string>;
 }

package/strategies/jwt.strategy.d.ts

@@ -1,13 +1,16 @@
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { ModuleRef } from '@nestjs/core';
 import { Request } from 'express';
-import { AuthConfigService } from '../services/auth-config.service';
 import { TokenPayload, TokenPayloadWithCompany } from '../interfaces/authentication.interface';
+import { AuthConfigService } from '../services/auth-config.service';
 declare const JwtStrategy_base: new (...args: any) => any;
 export declare class JwtStrategy extends JwtStrategy_base {
     private readonly authConfig;
     private readonly moduleRef;
     constructor(authConfig: AuthConfigService, moduleRef: ModuleRef);
     validate(_req: Request, payload: TokenPayload | TokenPayloadWithCompany): Promise<ILoggedUserInfo>;
+    private resolveUserRepository;
+    private checkTokenRevocation;
+    private buildUserInfo;
 }
 export {};

package/validators/password.validator.d.ts

@@ -0,0 +1,10 @@
+import { ValidationOptions } from 'class-validator';
+export interface PasswordComplexityOptions {
+    minLength?: number;
+    maxLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumber?: boolean;
+    requireSpecialChar?: boolean;
+}
+export declare function IsStrongPassword(options?: PasswordComplexityOptions, validationOptions?: ValidationOptions): (object: object, propertyName: string) => void;