306 lines
11 KiB
TypeScript
306 lines
11 KiB
TypeScript
import { InMemorySessionRepository } from '@/packages/infrastructure/repositories/InMemorySessionRepository';
|
|
import { MockBrowserAutomationAdapter } from '@/packages/infrastructure/adapters/automation/MockBrowserAutomationAdapter';
|
|
import { BrowserDevToolsAdapter } from '@/packages/infrastructure/adapters/automation/BrowserDevToolsAdapter';
|
|
import { NutJsAutomationAdapter } from '@/packages/infrastructure/adapters/automation/NutJsAutomationAdapter';
|
|
import { MockAutomationEngineAdapter } from '@/packages/infrastructure/adapters/automation/MockAutomationEngineAdapter';
|
|
import { PermissionService } from '@/packages/infrastructure/adapters/automation/PermissionService';
|
|
import { FixtureServerService } from '@/packages/infrastructure/adapters/automation/FixtureServerService';
|
|
import { StartAutomationSessionUseCase } from '@/packages/application/use-cases/StartAutomationSessionUseCase';
|
|
import { loadAutomationConfig, getAutomationMode, AutomationMode } from '@/packages/infrastructure/config';
|
|
import { PinoLogAdapter } from '@/packages/infrastructure/adapters/logging/PinoLogAdapter';
|
|
import { NoOpLogAdapter } from '@/packages/infrastructure/adapters/logging/NoOpLogAdapter';
|
|
import { loadLoggingConfig } from '@/packages/infrastructure/config/LoggingConfig';
|
|
import type { ISessionRepository } from '@/packages/application/ports/ISessionRepository';
|
|
import type { IBrowserAutomation } from '@/packages/application/ports/IBrowserAutomation';
|
|
import type { IAutomationEngine } from '@/packages/application/ports/IAutomationEngine';
|
|
import type { ILogger } from '@/packages/application/ports/ILogger';
|
|
import type { IFixtureServerService } from '@/packages/infrastructure/adapters/automation/FixtureServerService';
|
|
|
|
export interface BrowserConnectionResult {
|
|
success: boolean;
|
|
error?: string;
|
|
}
|
|
|
|
/**
|
|
* Create logger based on environment configuration.
|
|
* In test environment, returns NoOpLogAdapter for silent logging.
|
|
*/
|
|
function createLogger(): ILogger {
|
|
const config = loadLoggingConfig();
|
|
|
|
if (process.env.NODE_ENV === 'test') {
|
|
return new NoOpLogAdapter();
|
|
}
|
|
|
|
return new PinoLogAdapter(config);
|
|
}
|
|
|
|
/**
|
|
* Create browser automation adapter based on configuration mode.
|
|
*
|
|
* Mode mapping:
|
|
* - 'development' → BrowserDevToolsAdapter with fixture server URL
|
|
* - 'production' → NutJsAutomationAdapter with iRacing window
|
|
* - 'test' → MockBrowserAutomationAdapter
|
|
*
|
|
* @param mode - The automation mode from configuration
|
|
* @param logger - Logger instance for the adapter
|
|
* @returns IBrowserAutomation adapter instance
|
|
*/
|
|
function createBrowserAutomationAdapter(mode: AutomationMode, logger: ILogger): IBrowserAutomation {
|
|
const config = loadAutomationConfig();
|
|
|
|
switch (mode) {
|
|
case 'development':
|
|
return new BrowserDevToolsAdapter({
|
|
debuggingPort: config.devTools?.debuggingPort ?? 9222,
|
|
browserWSEndpoint: config.devTools?.browserWSEndpoint,
|
|
defaultTimeout: config.defaultTimeout,
|
|
launchBrowser: true,
|
|
headless: false,
|
|
startUrl: `http://localhost:${config.fixtureServer?.port ?? 3456}/01-hosted-racing.html`,
|
|
}, logger.child({ adapter: 'BrowserDevTools' }));
|
|
|
|
case 'production':
|
|
return new NutJsAutomationAdapter({
|
|
mouseSpeed: config.nutJs?.mouseSpeed,
|
|
keyboardDelay: config.nutJs?.keyboardDelay,
|
|
defaultTimeout: config.defaultTimeout,
|
|
}, logger.child({ adapter: 'NutJs' }));
|
|
|
|
case 'test':
|
|
default:
|
|
return new MockBrowserAutomationAdapter();
|
|
}
|
|
}
|
|
|
|
export class DIContainer {
|
|
private static instance: DIContainer;
|
|
|
|
private logger: ILogger;
|
|
private sessionRepository: ISessionRepository;
|
|
private browserAutomation: IBrowserAutomation;
|
|
private automationEngine: IAutomationEngine;
|
|
private startAutomationUseCase: StartAutomationSessionUseCase;
|
|
private automationMode: AutomationMode;
|
|
private permissionService: PermissionService;
|
|
private fixtureServer: IFixtureServerService | null = null;
|
|
private fixtureServerInitialized: boolean = false;
|
|
|
|
private constructor() {
|
|
// Initialize logger first - it's needed by other components
|
|
this.logger = createLogger();
|
|
|
|
this.automationMode = getAutomationMode();
|
|
this.logger.info('DIContainer initializing', {
|
|
automationMode: this.automationMode,
|
|
nodeEnv: process.env.NODE_ENV
|
|
});
|
|
|
|
const config = loadAutomationConfig();
|
|
|
|
this.sessionRepository = new InMemorySessionRepository();
|
|
this.browserAutomation = createBrowserAutomationAdapter(config.mode, this.logger);
|
|
this.automationEngine = new MockAutomationEngineAdapter(
|
|
this.browserAutomation,
|
|
this.sessionRepository
|
|
);
|
|
this.startAutomationUseCase = new StartAutomationSessionUseCase(
|
|
this.automationEngine,
|
|
this.browserAutomation,
|
|
this.sessionRepository
|
|
);
|
|
this.permissionService = new PermissionService(
|
|
this.logger.child({ service: 'PermissionService' })
|
|
);
|
|
|
|
this.logger.info('DIContainer initialized', {
|
|
automationMode: config.mode,
|
|
sessionRepositoryType: 'InMemorySessionRepository',
|
|
browserAutomationType: this.getBrowserAutomationType(config.mode)
|
|
});
|
|
}
|
|
|
|
private getBrowserAutomationType(mode: AutomationMode): string {
|
|
switch (mode) {
|
|
case 'development': return 'BrowserDevToolsAdapter';
|
|
case 'production': return 'NutJsAutomationAdapter';
|
|
case 'test':
|
|
default: return 'MockBrowserAutomationAdapter';
|
|
}
|
|
}
|
|
|
|
public static getInstance(): DIContainer {
|
|
if (!DIContainer.instance) {
|
|
DIContainer.instance = new DIContainer();
|
|
}
|
|
return DIContainer.instance;
|
|
}
|
|
|
|
public getStartAutomationUseCase(): StartAutomationSessionUseCase {
|
|
return this.startAutomationUseCase;
|
|
}
|
|
|
|
public getSessionRepository(): ISessionRepository {
|
|
return this.sessionRepository;
|
|
}
|
|
|
|
public getAutomationEngine(): IAutomationEngine {
|
|
return this.automationEngine;
|
|
}
|
|
|
|
public getAutomationMode(): AutomationMode {
|
|
return this.automationMode;
|
|
}
|
|
|
|
public getBrowserAutomation(): IBrowserAutomation {
|
|
return this.browserAutomation;
|
|
}
|
|
|
|
public getLogger(): ILogger {
|
|
return this.logger;
|
|
}
|
|
|
|
public getPermissionService(): PermissionService {
|
|
return this.permissionService;
|
|
}
|
|
|
|
/**
|
|
* Initialize fixture server for development mode.
|
|
* Starts an embedded HTTP server serving static HTML fixtures.
|
|
* This should be called before initializing browser connection.
|
|
*/
|
|
private async initializeFixtureServer(): Promise<BrowserConnectionResult> {
|
|
const config = loadAutomationConfig();
|
|
|
|
if (!config.fixtureServer?.autoStart) {
|
|
this.logger.debug('Fixture server auto-start disabled');
|
|
return { success: true };
|
|
}
|
|
|
|
if (this.fixtureServerInitialized) {
|
|
this.logger.debug('Fixture server already initialized');
|
|
return { success: true };
|
|
}
|
|
|
|
this.fixtureServer = new FixtureServerService();
|
|
const port = config.fixtureServer.port;
|
|
const fixturesPath = config.fixtureServer.fixturesPath;
|
|
|
|
try {
|
|
await this.fixtureServer.start(port, fixturesPath);
|
|
const isReady = await this.fixtureServer.waitForReady(5000);
|
|
|
|
if (!isReady) {
|
|
throw new Error('Fixture server failed to become ready within timeout');
|
|
}
|
|
|
|
this.fixtureServerInitialized = true;
|
|
this.logger.info(`Fixture server started on port ${port}`, {
|
|
port,
|
|
fixturesPath,
|
|
baseUrl: this.fixtureServer.getBaseUrl()
|
|
});
|
|
|
|
return { success: true };
|
|
} catch (error) {
|
|
const errorMsg = error instanceof Error ? error.message : 'Failed to start fixture server';
|
|
this.logger.error('Fixture server initialization failed', error instanceof Error ? error : new Error(errorMsg));
|
|
return { success: false, error: errorMsg };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initialize browser connection based on mode.
|
|
* In development mode, starts fixture server (if configured) then connects to browser via CDP.
|
|
* In production mode, connects to iRacing window via nut.js.
|
|
* In test mode, returns success immediately (no connection needed).
|
|
*/
|
|
public async initializeBrowserConnection(): Promise<BrowserConnectionResult> {
|
|
this.logger.info('Initializing browser connection', { mode: this.automationMode });
|
|
|
|
if (this.automationMode === 'development') {
|
|
const fixtureResult = await this.initializeFixtureServer();
|
|
if (!fixtureResult.success) {
|
|
return fixtureResult;
|
|
}
|
|
|
|
try {
|
|
const devToolsAdapter = this.browserAutomation as BrowserDevToolsAdapter;
|
|
await devToolsAdapter.connect();
|
|
this.logger.info('Browser connection established', { mode: 'development', adapter: 'BrowserDevTools' });
|
|
return { success: true };
|
|
} catch (error) {
|
|
const errorMsg = error instanceof Error ? error.message : 'Failed to connect to browser';
|
|
this.logger.error('Browser connection failed', error instanceof Error ? error : new Error(errorMsg), { mode: 'development' });
|
|
return {
|
|
success: false,
|
|
error: errorMsg
|
|
};
|
|
}
|
|
}
|
|
if (this.automationMode === 'production') {
|
|
try {
|
|
const nutJsAdapter = this.browserAutomation as NutJsAutomationAdapter;
|
|
const result = await nutJsAdapter.connect();
|
|
if (!result.success) {
|
|
this.logger.error('Browser connection failed', new Error(result.error || 'Unknown error'), { mode: 'production' });
|
|
return { success: false, error: result.error };
|
|
}
|
|
this.logger.info('Browser connection established', { mode: 'production', adapter: 'NutJs' });
|
|
return { success: true };
|
|
} catch (error) {
|
|
const errorMsg = error instanceof Error ? error.message : 'Failed to initialize nut.js';
|
|
this.logger.error('Browser connection failed', error instanceof Error ? error : new Error(errorMsg), { mode: 'production' });
|
|
return {
|
|
success: false,
|
|
error: errorMsg
|
|
};
|
|
}
|
|
}
|
|
this.logger.debug('Test mode - no browser connection needed');
|
|
return { success: true }; // Test mode doesn't need connection
|
|
}
|
|
|
|
/**
|
|
* Get the fixture server instance (may be null if not in development mode or not auto-started).
|
|
*/
|
|
public getFixtureServer(): IFixtureServerService | null {
|
|
return this.fixtureServer;
|
|
}
|
|
|
|
/**
|
|
* Shutdown the container and cleanup resources.
|
|
* Should be called when the application is closing.
|
|
*/
|
|
public async shutdown(): Promise<void> {
|
|
this.logger.info('DIContainer shutting down');
|
|
|
|
if (this.fixtureServer?.isRunning()) {
|
|
try {
|
|
await this.fixtureServer.stop();
|
|
this.logger.info('Fixture server stopped');
|
|
} catch (error) {
|
|
this.logger.error('Error stopping fixture server', error instanceof Error ? error : new Error('Unknown error'));
|
|
}
|
|
}
|
|
|
|
if (this.browserAutomation && 'disconnect' in this.browserAutomation) {
|
|
try {
|
|
await (this.browserAutomation as BrowserDevToolsAdapter).disconnect();
|
|
this.logger.info('Browser automation disconnected');
|
|
} catch (error) {
|
|
this.logger.error('Error disconnecting browser automation', error instanceof Error ? error : new Error('Unknown error'));
|
|
}
|
|
}
|
|
|
|
this.logger.info('DIContainer shutdown complete');
|
|
}
|
|
|
|
/**
|
|
* Reset the singleton instance (useful for testing with different configurations).
|
|
*/
|
|
public static resetInstance(): void {
|
|
DIContainer.instance = undefined as unknown as DIContainer;
|
|
}
|
|
} |