@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/router/modules/route-performance/domain/operations/performance-recording.ts

@@ -0,0 +1,151 @@
+import type { PerformanceState, RouteMetrics } from "../models";
+import { createPerformanceAlert, createRouteMetrics } from "../models";
+
+// Pure function to record render time
+export const recordRenderTime = (
+	state: PerformanceState,
+	path: string,
+	renderTime: number,
+	now: number,
+): PerformanceState => {
+	const existing = state.metrics[path] || createRouteMetrics(path);
+
+	const newMetrics: RouteMetrics = {
+		...existing,
+		renderTime,
+	};
+
+	let newAlerts = state.alerts;
+
+	// Check for slow render
+	if (renderTime > state.thresholds.slowRenderTime) {
+		const alert = createPerformanceAlert(
+			"warning",
+			"slow-render",
+			`Route ${path} took ${renderTime.toFixed(2)}ms to render`,
+			path,
+			now,
+		);
+		newAlerts = [...newAlerts, alert];
+	}
+
+	return {
+		...state,
+		metrics: {
+			...state.metrics,
+			[path]: newMetrics,
+		},
+		alerts: Object.freeze(newAlerts.slice(-100)),
+	};
+};
+
+// Pure function to increment navigation count
+export const incrementNavigationCount = (
+	state: PerformanceState,
+	path: string,
+	now: number,
+): PerformanceState => {
+	const existing = state.metrics[path] || createRouteMetrics(path);
+
+	const newMetrics: RouteMetrics = {
+		...existing,
+		navigationCount: existing.navigationCount + 1,
+		lastVisited: now,
+	};
+
+	return {
+		...state,
+		metrics: {
+			...state.metrics,
+			[path]: newMetrics,
+		},
+	};
+};
+
+// Pure function to record error
+export const recordError = (
+	state: PerformanceState,
+	path: string,
+	now: number,
+): PerformanceState => {
+	const existing = state.metrics[path] || createRouteMetrics(path);
+
+	const errorCount = existing.errorCount + 1;
+	const errorRate = errorCount / (existing.navigationCount + 1);
+
+	const newMetrics: RouteMetrics = {
+		...existing,
+		errorCount,
+	};
+
+	let newAlerts = state.alerts;
+
+	// Check for high error rate
+	if (errorRate > state.thresholds.highErrorRate) {
+		const alert = createPerformanceAlert(
+			"error",
+			"high-error-rate",
+			`Route ${path} has ${(errorRate * 100).toFixed(1)}% error rate`,
+			path,
+			now,
+		);
+		newAlerts = [...newAlerts, alert];
+	}
+
+	return {
+		...state,
+		metrics: {
+			...state.metrics,
+			[path]: newMetrics,
+		},
+		alerts: Object.freeze(newAlerts.slice(-100)),
+	};
+};
+
+// Pure function to record cache hit
+export const recordCacheHit = (
+	state: PerformanceState,
+	path: string,
+	hit: boolean,
+): PerformanceState => {
+	const existing = state.metrics[path] || createRouteMetrics(path);
+
+	const totalAccesses = existing.navigationCount + 1;
+	const hits = existing.cacheHitRate * existing.navigationCount + (hit ? 1 : 0);
+	const newHitRate = hits / totalAccesses;
+
+	const newMetrics: RouteMetrics = {
+		...existing,
+		cacheHitRate: newHitRate,
+	};
+
+	return {
+		...state,
+		metrics: {
+			...state.metrics,
+			[path]: newMetrics,
+		},
+	};
+};
+
+// Pure function to set bundle size
+export const setBundleSize = (
+	state: PerformanceState,
+	path: string,
+	size: number,
+): PerformanceState => {
+	const existing = state.metrics[path] || createRouteMetrics(path);
+
+	const newMetrics: RouteMetrics = {
+		...existing,
+		bundleSize: size,
+	};
+
+	return {
+		...state,
+		metrics: {
+			...state.metrics,
+			[path]: newMetrics,
+		},
+	};
+};

package/src/router/modules/route-performance/domain/operations/performance-reporting.ts

@@ -0,0 +1,32 @@
+import type { PerformanceState } from "../models";
+import {
+	getAllMetrics,
+	getCriticalAlerts,
+	getPerformanceScore,
+} from "./performance-queries";
+
+// Pure function to generate performance report
+export const generatePerformanceReport = (state: PerformanceState): string => {
+	const metrics = getAllMetrics(state);
+	let report = "Route Performance Report\n";
+	report += "========================\n\n";
+	report += `Total Routes: ${metrics.length}\n`;
+	report += `Performance Score: ${getPerformanceScore(state).toFixed(2)}/100\n`;
+	report += `Critical Alerts: ${getCriticalAlerts(state).length}\n\n`;
+
+	report += "Route Metrics:\n";
+	for (const metric of metrics) {
+		report += `\n${metric.path}\n`;
+		report += `  Load Time: ${metric.loadTime.toFixed(2)}ms\n`;
+		report += `  Render Time: ${metric.renderTime.toFixed(2)}ms\n`;
+		report += `  Avg Load Time: ${metric.averageLoadTime.toFixed(2)}ms\n`;
+		report += `  Navigation Count: ${metric.navigationCount}\n`;
+		report += `  Error Count: ${metric.errorCount}\n`;
+		report += `  Cache Hit Rate: ${(metric.cacheHitRate * 100).toFixed(1)}%\n`;
+		if (metric.bundleSize) {
+			report += `  Bundle Size: ${(metric.bundleSize / 1024).toFixed(2)}KB\n`;
+		}
+	}
+
+	return report;
+};

package/src/router/modules/route-performance/domain/operations/performance-tracking.ts

@@ -0,0 +1,75 @@
+import type { PerformanceState, RouteMetrics } from "../models";
+import { createPerformanceAlert, createRouteMetrics } from "../models";
+
+// Pure function to start load tracking
+export const startLoad = (
+	state: PerformanceState,
+	path: string,
+	now: number,
+): PerformanceState => {
+	return {
+		...state,
+		startTime: {
+			...state.startTime,
+			[path]: now,
+		},
+	};
+};
+
+// Pure function to end load tracking
+export const endLoad = (
+	state: PerformanceState,
+	path: string,
+	now: number,
+): PerformanceState => {
+	const start = state.startTime[path];
+	if (!start) return state;
+
+	const loadTime = now - start;
+	const existing = state.metrics[path] || createRouteMetrics(path);
+
+	// Track load times for average calculation
+	const times = state.loadTimes[path] || [];
+	const newTimes = [...times, loadTime];
+
+	const averageLoadTime =
+		newTimes.reduce((sum, t) => sum + t, 0) / newTimes.length;
+
+	const newMetrics: RouteMetrics = {
+		...existing,
+		loadTime,
+		averageLoadTime,
+		lastVisited: now,
+	};
+
+	let newAlerts = state.alerts;
+
+	// Check for slow routes
+	if (loadTime > state.thresholds.slowLoadTime) {
+		const alert = createPerformanceAlert(
+			"warning",
+			"slow-load",
+			`Route ${path} took ${loadTime.toFixed(2)}ms to load`,
+			path,
+			now,
+		);
+		newAlerts = [...newAlerts, alert];
+	}
+
+	return {
+		...state,
+		metrics: {
+			...state.metrics,
+			[path]: newMetrics,
+		},
+		loadTimes: {
+			...state.loadTimes,
+			[path]: newTimes,
+		},
+		startTime: {
+			...state.startTime,
+			[path]: 0,
+		},
+		alerts: Object.freeze(newAlerts.slice(-100)),
+	};
+};

package/src/router/modules/route-performance/domain/validators/index.ts

@@ -0,0 +1,55 @@
+import type { PerformanceThresholds, RouteMetrics } from "../models";
+
+export const validateRouteMetrics = (metrics: RouteMetrics): boolean => {
+	if (!metrics.path || typeof metrics.path !== "string") return false;
+	if (typeof metrics.loadTime !== "number" || metrics.loadTime < 0)
+		return false;
+	if (typeof metrics.renderTime !== "number" || metrics.renderTime < 0)
+		return false;
+	if (
+		typeof metrics.navigationCount !== "number" ||
+		metrics.navigationCount < 0
+	)
+		return false;
+	if (typeof metrics.errorCount !== "number" || metrics.errorCount < 0)
+		return false;
+	if (
+		typeof metrics.cacheHitRate !== "number" ||
+		metrics.cacheHitRate < 0 ||
+		metrics.cacheHitRate > 1
+	)
+		return false;
+	return true;
+};
+
+export const validateThresholds = (
+	thresholds: PerformanceThresholds,
+): boolean => {
+	if (
+		typeof thresholds.slowLoadTime !== "number" ||
+		thresholds.slowLoadTime <= 0
+	)
+		return false;
+	if (
+		typeof thresholds.slowRenderTime !== "number" ||
+		thresholds.slowRenderTime <= 0
+	)
+		return false;
+	if (
+		typeof thresholds.highErrorRate !== "number" ||
+		thresholds.highErrorRate < 0 ||
+		thresholds.highErrorRate > 1
+	)
+		return false;
+	return true;
+};
+
+export const validateLoadTime = (loadTime: number): boolean => {
+	return typeof loadTime === "number" && loadTime >= 0 && loadTime <= 60000;
+};
+
+export const validateRenderTime = (renderTime: number): boolean => {
+	return (
+		typeof renderTime === "number" && renderTime >= 0 && renderTime <= 30000
+	);
+};

package/src/router/modules/route-performance/index.ts

@@ -0,0 +1,8 @@
+// Public API exports for route-performance module
+
+export * from "./application/usecases";
+export * from "./domain/models";
+export * from "./domain/operations";
+export * from "./domain/validators";
+export * from "./ports";
+export * from "./types";

package/src/router/modules/route-performance/ports/index.ts

@@ -0,0 +1,25 @@
+import type {
+	PerformanceAlert,
+	PerformanceState,
+	RouteMetrics,
+} from "../types";
+
+// Port for performance metrics storage (dependency injection point)
+export interface IPerformanceStorage {
+	getMetrics(path: string): RouteMetrics | undefined;
+	setMetrics(path: string, metrics: RouteMetrics): void;
+	clearMetrics(path: string): void;
+	clearAll(): void;
+}
+
+// Port for performance reporting (dependency injection point)
+export interface IPerformanceReporter {
+	generateReport(state: PerformanceState): string;
+	sendReport(report: string): Promise<void>;
+}
+
+// Port for alert notification (dependency injection point)
+export interface IAlertNotifier {
+	notify(alert: PerformanceAlert): void;
+	subscribe(callback: (alert: PerformanceAlert) => void): () => void;
+}

package/src/router/modules/route-performance/types/index.ts

@@ -0,0 +1,6 @@
+export type {
+	PerformanceAlert,
+	PerformanceState,
+	PerformanceThresholds,
+	RouteMetrics,
+} from "../domain/models";

package/src/router/modules/route-security/application/usecases/index.ts

@@ -0,0 +1,153 @@
+import {
+	addGuard,
+	addPermission,
+	addRole,
+	addRoutePermission,
+	removeGuard,
+} from "../../domain/models";
+import {
+	canAccessRoute,
+	checkGuards,
+	clearAuditLogs,
+	getAuditLogs,
+	getUserPermissions,
+	getUserRoles,
+	hasPermission,
+	logAudit,
+} from "../../domain/operations";
+import type {
+	Permission,
+	Role,
+	RouteContext,
+	SecurityState,
+	User,
+} from "../../types";
+
+// Use case: Add guard to route
+export const addGuardUseCase = (
+	state: SecurityState,
+	path: string,
+	guard: (
+		match: import("../../../../shared/types").RouteMatch,
+	) =>
+		| import("../../../../shared/types").Result<void>
+		| Promise<import("../../../../shared/types").Result<void>>,
+): SecurityState => {
+	return {
+		...state,
+		guardRegistry: addGuard(state.guardRegistry, path, guard),
+	};
+};
+
+// Use case: Remove guard from route
+export const removeGuardUseCase = (
+	state: SecurityState,
+	path: string,
+	guard: (
+		match: import("../../../../shared/types").RouteMatch,
+	) =>
+		| import("../../../../shared/types").Result<void>
+		| Promise<import("../../../../shared/types").Result<void>>,
+): SecurityState => {
+	return {
+		...state,
+		guardRegistry: removeGuard(state.guardRegistry, path, guard),
+	};
+};
+
+// Use case: Check guards for route
+export const checkGuardsUseCase = async (
+	state: SecurityState,
+	match: import("../../../../shared/types").RouteMatch,
+): Promise<import("../../../../shared/types").Result<void>> => {
+	return checkGuards(state, match);
+};
+
+// Use case: Add role
+export const addRoleUseCase = (
+	state: SecurityState,
+	role: Role,
+): SecurityState => {
+	return addRole(state, role);
+};
+
+// Use case: Add permission
+export const addPermissionUseCase = (
+	state: SecurityState,
+	permission: Permission,
+): SecurityState => {
+	return addPermission(state, permission);
+};
+
+// Use case: Add route permission
+export const addRoutePermissionUseCase = (
+	state: SecurityState,
+	path: string,
+	permissionKey: string,
+): SecurityState => {
+	return addRoutePermission(state, path, permissionKey);
+};
+
+// Use case: Check if user has permission
+export const hasPermissionUseCase = (
+	state: SecurityState,
+	user: User,
+	resource: string,
+	action: string,
+	context?: RouteContext,
+): boolean => {
+	return hasPermission(state, user, resource, action, context);
+};
+
+// Use case: Check if user can access route
+export const canAccessRouteUseCase = (
+	state: SecurityState,
+	user: User,
+	routePath: string,
+	context: RouteContext,
+): { allowed: boolean; reason?: string } => {
+	return canAccessRoute(state, user, routePath, context);
+};
+
+// Use case: Get user roles
+export const getUserRolesUseCase = (
+	state: SecurityState,
+	user: User,
+): readonly string[] => {
+	return getUserRoles(state, user);
+};
+
+// Use case: Get user permissions
+export const getUserPermissionsUseCase = (
+	state: SecurityState,
+	user: User,
+): readonly string[] => {
+	return getUserPermissions(state, user);
+};
+
+// Use case: Log audit entry
+export const logAuditUseCase = (
+	state: SecurityState,
+	user: User,
+	action: string,
+	resource: string,
+	result: "allowed" | "denied",
+	now: number,
+	reason?: string,
+): SecurityState => {
+	return logAudit(state, user, action, resource, result, now, reason);
+};
+
+// Use case: Get audit logs
+export const getAuditLogsUseCase = (
+	state: SecurityState,
+	userId?: string,
+	limit = 100,
+): readonly import("../../domain/models").AuditLog[] => {
+	return getAuditLogs(state, userId, limit);
+};
+
+// Use case: Clear audit logs
+export const clearAuditLogsUseCase = (state: SecurityState): SecurityState => {
+	return clearAuditLogs(state);
+};