@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/router/modules/routing/domain/e2e-testing.ts

@@ -0,0 +1,267 @@
+import type { RouteConfig } from "../../../shared/types";
+
+export interface E2ETestStep {
+	action: "navigate" | "click" | "fill" | "wait" | "assert";
+	selector?: string;
+	value?: string;
+	assertion?: string;
+	timeout?: number;
+}
+
+export interface E2ETest {
+	name: string;
+	description: string;
+	route: string;
+	steps: E2ETestStep[];
+	expectedResult: string;
+}
+
+export interface E2ETestResult {
+	testName: string;
+	success: boolean;
+	duration: number;
+	error?: string;
+	steps: Array<{
+		step: E2ETestStep;
+		success: boolean;
+		error?: string;
+	}>;
+}
+
+export class E2ERouteTester {
+	private tests: E2ETest[] = [];
+	private results: E2ETestResult[] = [];
+
+	addTest(test: E2ETest): void {
+		this.tests.push(test);
+	}
+
+	getTests(): E2ETest[] {
+		return this.tests;
+	}
+
+	async runTest(
+		test: E2ETest,
+		startTime: number,
+		endTime: number,
+	): Promise<E2ETestResult> {
+		const stepResults: Array<{
+			step: E2ETestStep;
+			success: boolean;
+			error?: string;
+		}> = [];
+
+		for (const step of test.steps) {
+			try {
+				await this.executeStep(step);
+				stepResults.push({ step, success: true });
+			} catch (error) {
+				const errorMessage =
+					error instanceof Error ? error.message : String(error);
+				stepResults.push({ step, success: false, error: errorMessage });
+			}
+		}
+
+		const duration = endTime - startTime;
+		const allStepsSucceeded = stepResults.every((r) => r.success);
+		const firstError = stepResults.find((r) => !r.success)?.error;
+
+		const result: E2ETestResult = {
+			testName: test.name,
+			success: allStepsSucceeded,
+			duration,
+			steps: stepResults,
+		};
+
+		if (firstError !== undefined) {
+			result.error = firstError;
+		}
+
+		this.results.push(result);
+		return result;
+	}
+
+	async runAllTests(
+		startTime: number,
+		endTime: number,
+	): Promise<E2ETestResult[]> {
+		const results: E2ETestResult[] = [];
+
+		for (const test of this.tests) {
+			const result = await this.runTest(test, startTime, endTime);
+			results.push(result);
+		}
+
+		return results;
+	}
+
+	private async executeStep(step: E2ETestStep): Promise<void> {
+		switch (step.action) {
+			case "navigate":
+				await this.navigate(step.value || "");
+				break;
+			case "click":
+				await this.click(step.selector || "");
+				break;
+			case "fill":
+				await this.fill(step.selector || "", step.value || "");
+				break;
+			case "wait":
+				await this.wait(step.timeout || 1000);
+				break;
+			case "assert":
+				await this.assert(step.assertion || "");
+				break;
+		}
+	}
+
+	private async navigate(path: string): Promise<void> {
+		// Navigate to the specified path
+		window.history.pushState({}, "", path);
+		window.dispatchEvent(new PopStateEvent("popstate"));
+	}
+
+	private async click(selector: string): Promise<void> {
+		const element = document.querySelector(selector);
+		if (!element) {
+			throw new Error(`Element not found: ${selector}`);
+		}
+		(element as HTMLElement).click();
+	}
+
+	private async fill(selector: string, value: string): Promise<void> {
+		const element = document.querySelector(selector) as HTMLInputElement;
+		if (!element) {
+			throw new Error(`Element not found: ${selector}`);
+		}
+		element.value = value;
+		element.dispatchEvent(new Event("input", { bubbles: true }));
+	}
+
+	private async wait(timeout: number): Promise<void> {
+		return new Promise((resolve) => setTimeout(resolve, timeout));
+	}
+
+	private async assert(assertion: string): Promise<void> {
+		// Simple assertion implementation
+		// In a real implementation, this would evaluate the assertion
+		if (!assertion) {
+			throw new Error("Assertion is empty");
+		}
+	}
+
+	getResults(): E2ETestResult[] {
+		return this.results;
+	}
+
+	getTestStatistics(): {
+		total: number;
+		passed: number;
+		failed: number;
+		passRate: number;
+		averageDuration: number;
+	} {
+		const total = this.results.length;
+		const passed = this.results.filter((r) => r.success).length;
+		const failed = total - passed;
+		const passRate = total > 0 ? (passed / total) * 100 : 0;
+		const averageDuration =
+			total > 0
+				? this.results.reduce((sum, r) => sum + r.duration, 0) / total
+				: 0;
+
+		return {
+			total,
+			passed,
+			failed,
+			passRate,
+			averageDuration,
+		};
+	}
+
+	generateTestReport(): string {
+		const stats = this.getTestStatistics();
+		let report = "E2E Test Report\n";
+		report += "================\n\n";
+		report += `Total Tests: ${stats.total}\n`;
+		report += `Passed: ${stats.passed}\n`;
+		report += `Failed: ${stats.failed}\n`;
+		report += `Pass Rate: ${stats.passRate.toFixed(2)}%\n`;
+		report += `Average Duration: ${stats.averageDuration.toFixed(2)}ms\n\n`;
+
+		for (const result of this.results) {
+			report += `Test: ${result.testName}\n`;
+			report += `Status: ${result.success ? "PASSED" : "FAILED"}\n`;
+			report += `Duration: ${result.duration}ms\n`;
+			if (result.error) {
+				report += `Error: ${result.error}\n`;
+			}
+			report += "\n";
+		}
+
+		return report;
+	}
+
+	clearResults(): void {
+		this.results = [];
+	}
+
+	generateTestFromRoute(route: RouteConfig): E2ETest {
+		return {
+			name: `Test ${route.path}`,
+			description: `E2E test for route ${route.path}`,
+			route: route.path,
+			steps: [
+				{
+					action: "navigate",
+					value: route.path,
+				},
+				{
+					action: "wait",
+					timeout: 1000,
+				},
+				{
+					action: "assert",
+					assertion: "Page loaded successfully",
+				},
+			],
+			expectedResult: "Page should load without errors",
+		};
+	}
+
+	generateTestsFromRoutes(routes: RouteConfig[]): E2ETest[] {
+		return routes.map((route) => this.generateTestFromRoute(route));
+	}
+}
+
+export const createE2ERouteTester = (): E2ERouteTester => {
+	return new E2ERouteTester();
+};
+
+// Helper function to create a test step
+export function createTestStep(
+	action: E2ETestStep["action"],
+	options: Partial<E2ETestStep> = {},
+): E2ETestStep {
+	return {
+		action,
+		...options,
+	};
+}
+
+// Helper function to create an E2E test
+export function createE2ETest(
+	name: string,
+	route: string,
+	steps: E2ETestStep[],
+	description = "",
+	expectedResult = "",
+): E2ETest {
+	return {
+		name,
+		description,
+		route,
+		steps,
+		expectedResult,
+	};
+}

package/src/router/modules/routing/domain/error-boundaries.ts

@@ -0,0 +1,54 @@
+import type { RouteMatch } from "../../../shared/types";
+import { type Result, success } from "../../../shared/types";
+
+export type ErrorHandler = (error: Error, route: RouteMatch) => void;
+export type ErrorFallback = (error: Error, route: RouteMatch) => unknown;
+
+export class RouteErrorBoundary {
+	private errorHandlers: Map<string, ErrorHandler> = new Map();
+	private errorFallbacks: Map<string, ErrorFallback> = new Map();
+	private globalErrorHandler?: ErrorHandler;
+	private globalErrorFallback?: ErrorFallback;
+
+	setGlobalErrorHandler(handler: ErrorHandler): void {
+		this.globalErrorHandler = handler;
+	}
+
+	setGlobalErrorFallback(fallback: ErrorFallback): void {
+		this.globalErrorFallback = fallback;
+	}
+
+	addErrorHandler(path: string, handler: ErrorHandler): void {
+		this.errorHandlers.set(path, handler);
+	}
+
+	addErrorFallback(path: string, fallback: ErrorFallback): void {
+		this.errorFallbacks.set(path, fallback);
+	}
+
+	handleError(error: Error, route: RouteMatch): Result<void> {
+		const handler =
+			this.errorHandlers.get(route.path) || this.globalErrorHandler;
+		if (handler) {
+			handler(error, route);
+		}
+		return success(undefined);
+	}
+
+	getErrorFallback(route: RouteMatch): ErrorFallback | null {
+		return (
+			this.errorFallbacks.get(route.path) || this.globalErrorFallback || null
+		);
+	}
+}
+
+export const createRouteErrorBoundary = (): RouteErrorBoundary => {
+	return new RouteErrorBoundary();
+};
+
+export const createDefaultErrorFallback: ErrorFallback = (error) => {
+	return {
+		error: error.message,
+		stack: error.stack,
+	};
+};

package/src/router/modules/routing/domain/error-tracking.ts

@@ -0,0 +1,277 @@
+export interface RouteError {
+	timestamp: number;
+	route: string;
+	error: Error;
+	errorType: string;
+	stackTrace?: string;
+	userAgent?: string;
+	userContext?: Record<string, unknown>;
+	metadata?: Record<string, unknown>;
+}
+
+export interface ErrorAggregation {
+	route: string;
+	errorType: string;
+	count: number;
+	firstSeen: number;
+	lastSeen: number;
+	affectedUsers: Set<string>;
+}
+
+export class RouteErrorTracker {
+	private errors: RouteError[] = [];
+	private aggregations: Map<string, ErrorAggregation> = new Map();
+	private maxErrors = 1000;
+	private maxAggregations = 100;
+
+	recordError(
+		route: string,
+		error: Error,
+		now: number,
+		userContext?: Record<string, unknown>,
+		metadata?: Record<string, unknown>,
+		userAgent?: string,
+	): void {
+		const routeError: RouteError = {
+			timestamp: now,
+			route,
+			error,
+			errorType: error.name,
+			...(error.stack !== undefined && { stackTrace: error.stack }),
+			...(userAgent !== undefined && { userAgent }),
+			...(userContext !== undefined && { userContext }),
+			...(metadata !== undefined && { metadata }),
+		};
+
+		this.errors.push(routeError);
+
+		// Keep only last maxErrors
+		if (this.errors.length > this.maxErrors) {
+			this.errors = this.errors.slice(-this.maxErrors);
+		}
+
+		// Update aggregation
+		this.updateAggregation(routeError);
+	}
+
+	private updateAggregation(error: RouteError): void {
+		const key = `${error.route}:${error.errorType}`;
+		const existing = this.aggregations.get(key);
+
+		if (existing) {
+			existing.count++;
+			existing.lastSeen = error.timestamp;
+			if (error.userContext?.userId) {
+				existing.affectedUsers.add(String(error.userContext.userId));
+			}
+		} else {
+			const affectedUsers = new Set<string>();
+			if (error.userContext?.userId) {
+				affectedUsers.add(String(error.userContext.userId));
+			}
+
+			this.aggregations.set(key, {
+				route: error.route,
+				errorType: error.errorType,
+				count: 1,
+				firstSeen: error.timestamp,
+				lastSeen: error.timestamp,
+				affectedUsers,
+			});
+
+			// Keep only last maxAggregations
+			if (this.aggregations.size > this.maxAggregations) {
+				const oldestKey = this.getOldestAggregationKey();
+				if (oldestKey) {
+					this.aggregations.delete(oldestKey);
+				}
+			}
+		}
+	}
+
+	private getOldestAggregationKey(): string | null {
+		let oldestKey: string | null = null;
+		let oldestTime = Infinity;
+
+		for (const [key, agg] of this.aggregations) {
+			if (agg.firstSeen < oldestTime) {
+				oldestTime = agg.firstSeen;
+				oldestKey = key;
+			}
+		}
+
+		return oldestKey;
+	}
+
+	getErrors(route?: string): RouteError[] {
+		if (route) {
+			return this.errors.filter((e) => e.route === route);
+		}
+		return [...this.errors];
+	}
+
+	getErrorsByType(errorType: string): RouteError[] {
+		return this.errors.filter((e) => e.errorType === errorType);
+	}
+
+	getErrorsInTimeRange(startTime: number, endTime: number): RouteError[] {
+		return this.errors.filter(
+			(e) => e.timestamp >= startTime && e.timestamp <= endTime,
+		);
+	}
+
+	getAggregations(): ErrorAggregation[] {
+		return Array.from(this.aggregations.values());
+	}
+
+	getAggregationsByRoute(route: string): ErrorAggregation[] {
+		return this.getAggregations().filter((a) => a.route === route);
+	}
+
+	getTopErrors(limit = 10): ErrorAggregation[] {
+		return this.getAggregations()
+			.sort((a, b) => b.count - a.count)
+			.slice(0, limit);
+	}
+
+	getErrorRate(route: string, now: number, timeWindowMs = 60000): number {
+		const recentErrors = this.errors.filter(
+			(e) => e.route === route && e.timestamp >= now - timeWindowMs,
+		);
+		return recentErrors.length;
+	}
+
+	getErrorStatistics(now: number): {
+		totalErrors: number;
+		uniqueRoutes: number;
+		uniqueErrorTypes: number;
+		topError: string | null;
+		errorRate: number;
+	} {
+		const uniqueRoutes = new Set(this.errors.map((e) => e.route)).size;
+		const uniqueErrorTypes = new Set(this.errors.map((e) => e.errorType)).size;
+		const topError = this.getTopErrors(1)[0] || null;
+
+		// Calculate error rate (errors per minute in last hour)
+		const lastHourErrors = this.errors.filter(
+			(e) => e.timestamp >= now - 3600000,
+		);
+		const errorRate = lastHourErrors.length / 60;
+
+		return {
+			totalErrors: this.errors.length,
+			uniqueRoutes,
+			uniqueErrorTypes,
+			topError: topError ? `${topError.route}:${topError.errorType}` : null,
+			errorRate,
+		};
+	}
+
+	clearErrors(route?: string): void {
+		if (route) {
+			this.errors = this.errors.filter((e) => e.route !== route);
+		} else {
+			this.errors = [];
+		}
+	}
+
+	clearAggregations(route?: string): void {
+		if (route) {
+			for (const [key, agg] of this.aggregations) {
+				if (agg.route === route) {
+					this.aggregations.delete(key);
+				}
+			}
+		} else {
+			this.aggregations.clear();
+		}
+	}
+
+	clearAll(): void {
+		this.errors = [];
+		this.aggregations.clear();
+	}
+
+	setMaxErrors(max: number): void {
+		this.maxErrors = max;
+		if (this.errors.length > max) {
+			this.errors = this.errors.slice(-max);
+		}
+	}
+
+	setMaxAggregations(max: number): void {
+		this.maxAggregations = max;
+		while (this.aggregations.size > max) {
+			const oldestKey = this.getOldestAggregationKey();
+			if (oldestKey) {
+				this.aggregations.delete(oldestKey);
+			}
+		}
+	}
+
+	generateErrorReport(now: number): string {
+		const stats = this.getErrorStatistics(now);
+		let report = "Route Error Report\n";
+		report += "===================\n\n";
+		report += `Total Errors: ${stats.totalErrors}\n`;
+		report += `Unique Routes: ${stats.uniqueRoutes}\n`;
+		report += `Unique Error Types: ${stats.uniqueErrorTypes}\n`;
+		report += `Error Rate: ${stats.errorRate.toFixed(2)}/min\n`;
+		if (stats.topError) {
+			report += `Top Error: ${stats.topError}\n`;
+		}
+		report += "\n";
+
+		report += "Top Errors:\n";
+		const topErrors = this.getTopErrors(5);
+		for (const error of topErrors) {
+			report += `\n${error.route} - ${error.errorType}\n`;
+			report += `  Count: ${error.count}\n`;
+			report += `  Affected Users: ${error.affectedUsers.size}\n`;
+			report += `  First Seen: ${new Date(error.firstSeen).toISOString()}\n`;
+			report += `  Last Seen: ${new Date(error.lastSeen).toISOString()}\n`;
+		}
+
+		return report;
+	}
+
+	exportErrorsAsJSON(now: number): string {
+		return JSON.stringify(
+			{
+				statistics: this.getErrorStatistics(now),
+				aggregations: this.getAggregations().map((a) => ({
+					...a,
+					affectedUsers: Array.from(a.affectedUsers),
+				})),
+				recentErrors: this.errors.slice(-50),
+			},
+			null,
+			2,
+		);
+	}
+}
+
+export const createRouteErrorTracker = (): RouteErrorTracker => {
+	return new RouteErrorTracker();
+};
+
+// Helper function to create a route error
+export function createRouteError(
+	route: string,
+	error: Error,
+	now: number,
+	userContext?: Record<string, unknown>,
+	metadata?: Record<string, unknown>,
+	userAgent?: string,
+): RouteError {
+	return {
+		timestamp: now,
+		route,
+		error,
+		errorType: error.name,
+		...(error.stack !== undefined && { stackTrace: error.stack }),
+		...(userAgent !== undefined && { userAgent }),
+		...(userContext !== undefined && { userContext }),
+		...(metadata !== undefined && { metadata }),
+	};
+}