mmintel/gridpilot.gg
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

wip

Browse Source
This commit is contained in:
Marc Mintel
2025-12-14 18:11:59 +01:00
parent acc15e8d8d
commit 217337862c
91 changed files with 5919 additions and 1999 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
packages/automation/application/ports/ILogger.ts Normal file
View File

@@ -0,0 +1,7 @@
export interface ILogger {
debug(message: string, context?: Record<string, any>): void;
info(message: string, context?: Record<string, any>): void;
warn(message: string, context?: Record<string, any>): void;
error(message: string, error?: Error, context?: Record<string, any>): void;
verbose?(message: string, context?: Record<string, any>): void;
}

3
packages/automation/application/ports/LoggerPort.ts
View File

@@ -1,10 +1,11 @@
import type { LogLevel } from './LoggerLogLevel';
import type { LogContext } from './LoggerContext';
import type { ILogger } from '@gridpilot/shared/logging/ILogger';
/**
* LoggerPort - Port interface for application-layer logging.
*/
export interface LoggerPort {
export interface LoggerPort extends ILogger {
debug(message: string, context?: LogContext): void;
info(message: string, context?: LogContext): void;
warn(message: string, context?: LogContext): void;

123
packages/automation/application/use-cases/CheckAuthenticationUseCase.ts
View File

@@ -1,4 +1,5 @@
import { AuthenticationState } from '../../domain/value-objects/AuthenticationState';
import type { ILogger } from '../../../shared/src/logging/ILogger';
import { Result } from '../../../shared/result/Result';
import type { AuthenticationServicePort } from '../ports/AuthenticationServicePort';
import { SessionLifetime } from '../../domain/value-objects/SessionLifetime';
@@ -16,6 +17,7 @@ import type { SessionValidatorPort } from '../ports/SessionValidatorPort';
*/
export class CheckAuthenticationUseCase {
constructor(
private readonly logger: ILogger,
private readonly authService: AuthenticationServicePort,
private readonly sessionValidator?: SessionValidatorPort
) {}
@@ -30,63 +32,88 @@ export class CheckAuthenticationUseCase {
requireServerValidation?: boolean;
verifyPageContent?: boolean;
}): Promise<Result<AuthenticationState>> {
// Step 1: File-based validation (fast)
const fileResult = await this.authService.checkSession();
if (fileResult.isErr()) {
return fileResult;
}
const fileState = fileResult.unwrap();
// Step 2: Check session expiry if authenticated
if (fileState === AuthenticationState.AUTHENTICATED) {
const expiryResult = await this.authService.getSessionExpiry();
if (expiryResult.isErr()) {
// Don't fail completely if we can't get expiry, use file-based state
return Result.ok(fileState);
this.logger.debug('Executing CheckAuthenticationUseCase', { options });
try {
// Step 1: File-based validation (fast)
this.logger.debug('Performing file-based authentication check.');
const fileResult = await this.authService.checkSession();
if (fileResult.isErr()) {
this.logger.error('File-based authentication check failed.', { error: fileResult.unwrapErr() });
return fileResult;
}
this.logger.info('File-based authentication check succeeded.');
const expiry = expiryResult.unwrap();
if (expiry !== null) {
try {
const sessionLifetime = new SessionLifetime(expiry);
if (sessionLifetime.isExpired()) {
const fileState = fileResult.unwrap();
this.logger.debug(`File-based authentication state: ${fileState}`);
// Step 2: Check session expiry if authenticated
if (fileState === AuthenticationState.AUTHENTICATED) {
this.logger.debug('Session is authenticated, checking expiry.');
const expiryResult = await this.authService.getSessionExpiry();
if (expiryResult.isErr()) {
this.logger.warn('Could not retrieve session expiry, proceeding with file-based state.', { error: expiryResult.unwrapErr() });
// Don't fail completely if we can't get expiry, use file-based state
return Result.ok(fileState);
}
const expiry = expiryResult.unwrap();
if (expiry !== null) {
try {
const sessionLifetime = new SessionLifetime(expiry);
if (sessionLifetime.isExpired()) {
this.logger.info('Session has expired based on lifetime.');
return Result.ok(AuthenticationState.EXPIRED);
}
this.logger.debug('Session is not expired.');
} catch (error) {
this.logger.error('Invalid expiry date encountered, treating session as expired.', { expiry, error });
// Invalid expiry date, treat as expired for safety
return Result.ok(AuthenticationState.EXPIRED);
}
} catch {
// Invalid expiry date, treat as expired for safety
return Result.ok(AuthenticationState.EXPIRED);
}
}
}
// Step 3: Optional page content verification
if (options?.verifyPageContent && fileState === AuthenticationState.AUTHENTICATED) {
const pageResult = await this.authService.verifyPageAuthentication();
if (pageResult.isOk()) {
const browserState = pageResult.unwrap();
// If cookies valid but page shows login UI, session is expired
if (!browserState.isFullyAuthenticated()) {
return Result.ok(AuthenticationState.EXPIRED);
// Step 3: Optional page content verification
if (options?.verifyPageContent && fileState === AuthenticationState.AUTHENTICATED) {
this.logger.debug('Performing optional page content verification.');
const pageResult = await this.authService.verifyPageAuthentication();
if (pageResult.isOk()) {
const browserState = pageResult.unwrap();
// If cookies valid but page shows login UI, session is expired
if (!browserState.isFullyAuthenticated()) {
this.logger.info('Page content verification indicated session expired.');
return Result.ok(AuthenticationState.EXPIRED);
}
this.logger.info('Page content verification succeeded.');
} else {
this.logger.warn('Page content verification failed, proceeding with file-based state.', { error: pageResult.unwrapErr() });
}
// Don't block on page verification errors, continue with file-based state
}
// Step 4: Optional server-side validation
if (this.sessionValidator && fileState === AuthenticationState.AUTHENTICATED) {
this.logger.debug('Performing optional server-side validation.');
const serverResult = await this.sessionValidator.validateSession();
// Don't block on server validation errors
if (serverResult.isOk()) {
const isValid = serverResult.unwrap();
if (!isValid) {
this.logger.info('Server-side validation indicated session expired.');
return Result.ok(AuthenticationState.EXPIRED);
}
this.logger.info('Server-side validation succeeded.');
} else {
this.logger.warn('Server-side validation failed, proceeding with file-based state.', { error: serverResult.unwrapErr() });
}
}
// Don't block on page verification errors, continue with file-based state
this.logger.info(`CheckAuthenticationUseCase completed successfully with state: ${fileState}`);
return Result.ok(fileState);
} catch (error) {
this.logger.error('An unexpected error occurred during authentication check.', { error });
throw error;
}
// Step 4: Optional server-side validation
if (this.sessionValidator && fileState === AuthenticationState.AUTHENTICATED) {
const serverResult = await this.sessionValidator.validateSession();
// Don't block on server validation errors
if (serverResult.isOk()) {
const isValid = serverResult.unwrap();
if (!isValid) {
return Result.ok(AuthenticationState.EXPIRED);
}
}
}
return Result.ok(fileState);
}
}

32
packages/automation/application/use-cases/ClearSessionUseCase.ts
View File

@@ -1,5 +1,6 @@
import { Result } from '../../../shared/result/Result';
import type { AuthenticationServicePort } from '../ports/AuthenticationServicePort';
import type { ILogger } from '../../../shared/src/logging/ILogger';
/**
* Use case for clearing the user's session (logout).
@@ -8,7 +9,10 @@ import type { AuthenticationServicePort } from '../ports/AuthenticationServicePo
* the user out. The next automation attempt will require re-authentication.
*/
export class ClearSessionUseCase {
constructor(private readonly authService: AuthenticationServicePort) {}
constructor(
private readonly authService: AuthenticationServicePort,
private readonly logger: ILogger, // Inject ILogger
) {}
/**
* Execute the session clearing.
@@ -16,6 +20,28 @@ export class ClearSessionUseCase {
* @returns Result indicating success or failure
*/
async execute(): Promise<Result<void>> {
return this.authService.clearSession();
this.logger.debug('Attempting to clear user session.', {
useCase: 'ClearSessionUseCase'
});
try {
const result = await this.authService.clearSession();
if (result.isSuccess) {
this.logger.info('User session cleared successfully.', {
useCase: 'ClearSessionUseCase'
});
} else {
this.logger.warn('Failed to clear user session.', {
useCase: 'ClearSessionUseCase',
error: result.error,
});
}
return result;
} catch (error: any) {
this.logger.error('Error clearing user session.', error, {
useCase: 'ClearSessionUseCase'
});
return Result.fail(error.message);
}
}
}
}

10
packages/automation/application/use-cases/CompleteRaceCreationUseCase.ts
View File

@@ -1,24 +1,30 @@
import { Result } from '../../../shared/result/Result';
import { RaceCreationResult } from '../../domain/value-objects/RaceCreationResult';
import type { CheckoutServicePort } from '../ports/CheckoutServicePort';
import type { ILogger } from '../../../shared/src/logging/ILogger';
export class CompleteRaceCreationUseCase {
constructor(private readonly checkoutService: CheckoutServicePort) {}
constructor(private readonly checkoutService: CheckoutServicePort, private readonly logger: ILogger) {}
async execute(sessionId: string): Promise<Result<RaceCreationResult>> {
this.logger.debug(`Attempting to complete race creation for session ID: ${sessionId}`);
if (!sessionId || sessionId.trim() === '') {
this.logger.error('Session ID is required for completing race creation.');
return Result.err(new Error('Session ID is required'));
}
const infoResult = await this.checkoutService.extractCheckoutInfo();
if (infoResult.isErr()) {
this.logger.error(`Failed to extract checkout info: ${infoResult.unwrapErr().message}`);
return Result.err(infoResult.unwrapErr());
}
const info = infoResult.unwrap();
this.logger.debug(`Extracted checkout information: ${JSON.stringify(info)}`);
if (!info.price) {
this.logger.error('Could not extract price from checkout page.');
return Result.err(new Error('Could not extract price from checkout page'));
}
@@ -29,9 +35,11 @@ export class CompleteRaceCreationUseCase {
timestamp: new Date(),
});
this.logger.info(`Race creation completed successfully for session ID: ${sessionId}`);
return Result.ok(raceCreationResult);
} catch (error) {
const err = error instanceof Error ? error : new Error('Unknown error');
this.logger.error(`Error completing race creation for session ID ${sessionId}: ${err.message}`);
return Result.err(err);
}
}

27
packages/automation/application/use-cases/ConfirmCheckoutUseCase.ts
View File

@@ -1,4 +1,5 @@
import { Result } from '../../../shared/result/Result';
import type { ILogger } from '../../../shared/src/logging/ILogger';
import type { CheckoutServicePort } from '../ports/CheckoutServicePort';
import type { CheckoutConfirmationPort } from '../ports/CheckoutConfirmationPort';
import { CheckoutStateEnum } from '../../domain/value-objects/CheckoutState';
@@ -14,26 +15,36 @@ export class ConfirmCheckoutUseCase {
constructor(
private readonly checkoutService: CheckoutServicePort,
private readonly confirmationPort: CheckoutConfirmationPort
private readonly confirmationPort: CheckoutConfirmationPort,
private readonly logger: ILogger,
) {}
async execute(sessionMetadata?: SessionMetadata): Promise<Result<void>> {
this.logger.debug('Executing ConfirmCheckoutUseCase', { sessionMetadata });
const infoResult = await this.checkoutService.extractCheckoutInfo();
if (infoResult.isErr()) {
this.logger.error('Failed to extract checkout info', { error: infoResult.unwrapErr() });
return Result.err(infoResult.unwrapErr());
}
const info = infoResult.unwrap();
this.logger.info('Extracted checkout info', { state: info.state.getValue(), price: info.price });
if (info.state.getValue() === CheckoutStateEnum.INSUFFICIENT_FUNDS) {
this.logger.error('Insufficient funds to complete checkout');
return Result.err(new Error('Insufficient funds to complete checkout'));
}
if (!info.price) {
this.logger.error('Could not extract price from checkout page');
return Result.err(new Error('Could not extract price from checkout page'));
}
this.logger.debug('Requesting checkout confirmation', { price: info.price, state: info.state.getValue(), sessionMetadata });
// Request confirmation via port with full checkout context
const confirmationResult = await this.confirmationPort.requestCheckoutConfirmation({
price: info.price,
@@ -47,19 +58,31 @@ export class ConfirmCheckoutUseCase {
});
if (confirmationResult.isErr()) {
this.logger.error('Checkout confirmation failed', { error: confirmationResult.unwrapErr() });
return Result.err(confirmationResult.unwrapErr());
}
const confirmation = confirmationResult.unwrap();
this.logger.info('Checkout confirmation received', { confirmation });
if (confirmation.isCancelled()) {
this.logger.error('Checkout cancelled by user');
return Result.err(new Error('Checkout cancelled by user'));
}
if (confirmation.isTimeout()) {
this.logger.error('Checkout confirmation timeout');
return Result.err(new Error('Checkout confirmation timeout'));
}
return await this.checkoutService.proceedWithCheckout();
this.logger.info('Proceeding with checkout');
const checkoutResult = await this.checkoutService.proceedWithCheckout();
if (checkoutResult.isOk()) {
this.logger.info('Checkout process completed successfully.');
} else {
this.logger.error('Checkout process failed', { error: checkoutResult.unwrapErr() });
}
return checkoutResult;
}
}

20
packages/automation/application/use-cases/InitiateLoginUseCase.ts
View File

@@ -1,5 +1,6 @@
import { Result } from '../../../shared/result/Result';
import type { AuthenticationServicePort } from '../ports/AuthenticationServicePort';
import type { ILogger } from '../../../shared/logger/ILogger';
/**
* Use case for initiating the manual login flow.
@@ -9,7 +10,10 @@ import type { AuthenticationServicePort } from '../ports/AuthenticationServicePo
* indicating successful login.
*/
export class InitiateLoginUseCase {
constructor(private readonly authService: AuthenticationServicePort) {}
constructor(
private readonly authService: AuthenticationServicePort,
private readonly logger: ILogger,
) {}
/**
* Execute the login flow.
@@ -18,6 +22,18 @@ export class InitiateLoginUseCase {
* @returns Result indicating success (login complete) or failure (cancelled/timeout)
*/
async execute(): Promise<Result<void>> {
return this.authService.initiateLogin();
this.logger.debug('Initiating login flow...');
try {
const result = await this.authService.initiateLogin();
if (result.isOk()) {
this.logger.info('Login flow initiated successfully.');
} else {
this.logger.warn('Login flow initiation failed.', { error: result.error });
}
return result;
} catch (error: any) {
this.logger.error('Error initiating login flow.', error);
return Result.fail(error.message || 'Unknown error during login initiation.');
}
}
}

12
packages/automation/application/use-cases/StartAutomationSessionUseCase.ts
View File

@@ -1,4 +1,5 @@
import type { AsyncUseCase } from '@gridpilot/shared/application';
import type { ILogger } from '../../../shared/src/logging/ILogger';
import { AutomationSession } from '../../domain/entities/AutomationSession';
import type { HostedSessionConfig } from '../../domain/types/HostedSessionConfig';
import { AutomationEnginePort } from '../ports/AutomationEnginePort';
@@ -11,18 +12,26 @@ export class StartAutomationSessionUseCase
constructor(
private readonly automationEngine: AutomationEnginePort,
private readonly browserAutomation: IBrowserAutomation,
private readonly sessionRepository: SessionRepositoryPort
private readonly sessionRepository: SessionRepositoryPort,
private readonly logger: ILogger
) {}
async execute(config: HostedSessionConfig): Promise<SessionDTO> {
this.logger.debug('Starting automation session execution', { config });
const session = AutomationSession.create(config);
this.logger.info(`Automation session created with ID: ${session.id}`);
const validationResult = await this.automationEngine.validateConfiguration(config);
if (!validationResult.isValid) {
this.logger.warn('Automation session configuration validation failed', { config, error: validationResult.error });
this.logger.error('Automation session configuration validation failed', { config, error: validationResult.error });
throw new Error(validationResult.error);
}
this.logger.debug('Automation session configuration validated successfully.');
await this.sessionRepository.save(session);
this.logger.info(`Automation session with ID: ${session.id} saved to repository.`);
const dto: SessionDTO = {
sessionId: session.id,
@@ -34,6 +43,7 @@ export class StartAutomationSessionUseCase
...(session.errorMessage ? { errorMessage: session.errorMessage } : {}),
};
this.logger.debug('Automation session executed successfully, returning DTO.', { dto });
return dto;
}
}

8
packages/automation/application/use-cases/VerifyAuthenticatedPageUseCase.ts
View File

@@ -1,6 +1,7 @@
import type { AuthenticationServicePort } from '../ports/AuthenticationServicePort';
import { Result } from '../../../shared/result/Result';
import { BrowserAuthenticationState } from '../../domain/value-objects/BrowserAuthenticationState';
import type { ILogger } from '../../../shared/src/logging/ILogger';
/**
* Use case for verifying browser shows authenticated page state.
@@ -8,22 +9,27 @@ import { BrowserAuthenticationState } from '../../domain/value-objects/BrowserAu
*/
export class VerifyAuthenticatedPageUseCase {
constructor(
private readonly authService: AuthenticationServicePort
private readonly authService: AuthenticationServicePort,
private readonly logger: ILogger,
) {}
async execute(): Promise<Result<BrowserAuthenticationState>> {
this.logger.debug('Executing VerifyAuthenticatedPageUseCase');
try {
const result = await this.authService.verifyPageAuthentication();
if (result.isErr()) {
const error = result.error ?? new Error('Page verification failed');
this.logger.error(`Page verification failed: ${error.message}`, error);
return Result.err<BrowserAuthenticationState>(error);
}
const browserState = result.unwrap();
this.logger.info('Successfully verified authenticated page state.');
return Result.ok<BrowserAuthenticationState>(browserState);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
this.logger.error(`Page verification failed unexpectedly: ${message}`, error);
return Result.err<BrowserAuthenticationState>(new Error(`Page verification failed: ${message}`));
}
}