@flusys/nestjs-auth 1.0.0-beta → 1.0.0-rc

package/services/authentication.service.d.ts

@@ -1,14 +1,13 @@
 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 { LoginResponse, LoginResponseRequiresEmailVerification, LoginResponseRequiresSelection, MeResponse, RegistrationResponse } from '../interfaces/authentication.interface';
+import { AuthEmailService } from './auth-email.service';
 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 { CompanySelectionSessionService } from './company-selection-session.service';
 export declare class AuthenticationService {
     private readonly jwtService;
@@ -16,20 +15,24 @@ 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 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>;
+    register(dto: RegistrationDto, verifyUrlBase?: string): Promise<RegistrationResponse | {
+        requiresEmailVerification: true;
+        message: string;
+    }>;
+    private createUserDirectly;
+    createUserFromPendingRegistration(pending: PendingRegistration): Promise<RegistrationResponse>;
+    private handleCompanyRegistrationFromPending;
     private handleCompanyRegistration;
+    private processCompanyRegistration;
     private generateSlug;
     select(sessionId: string, companyId: string, branchId: string): Promise<LoginResponse>;
     switchCompany(userId: string, companyId: string, branchId: string): Promise<LoginResponse>;
@@ -51,4 +54,6 @@ export declare class AuthenticationService {
     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

@@ -3,7 +3,6 @@ import { UserCompanyPermission } from '../entities/user-company-permission.entit
 import { AuthDataSourceProvider } from './auth-datasource.provider';
 export declare class UserPermissionService {
     private readonly dataSourceProvider;
-    private readonly logger;
     private _repository;
     constructor(dataSourceProvider: AuthDataSourceProvider);
     private getRepository;

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 validateProfileOwnership;
     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/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;