@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/router/modules/route-error-tracking/domain/models/index.ts

@@ -0,0 +1,130 @@
+export interface RouteError {
+	readonly timestamp: number;
+	readonly route: string;
+	readonly error: Error;
+	readonly errorType: string;
+	readonly stackTrace?: string;
+	readonly userAgent?: string;
+	readonly userContext?: Readonly<Record<string, unknown>>;
+	readonly metadata?: Readonly<Record<string, unknown>>;
+}
+
+export interface ErrorAggregation {
+	readonly route: string;
+	readonly errorType: string;
+	readonly count: number;
+	readonly firstSeen: number;
+	readonly lastSeen: number;
+	readonly affectedUsers: ReadonlySet<string>;
+}
+
+export interface ErrorTrackingConfig {
+	readonly maxErrors: number;
+	readonly maxAggregations: number;
+}
+
+export type ErrorTrackingState = {
+	readonly errors: readonly RouteError[];
+	readonly aggregations: Readonly<Record<string, ErrorAggregation>>;
+	readonly config: ErrorTrackingConfig;
+};
+
+// Pure function to create initial error tracking state
+export const createErrorTrackingState = (
+	config?: Partial<ErrorTrackingConfig>,
+): ErrorTrackingState => {
+	const defaultConfig: ErrorTrackingConfig = {
+		maxErrors: 1000,
+		maxAggregations: 100,
+	};
+
+	return Object.freeze({
+		errors: Object.freeze([]),
+		aggregations: Object.freeze({}),
+		config: config ? { ...defaultConfig, ...config } : defaultConfig,
+	});
+};
+
+// Pure function to create a route error
+export const createRouteError = (
+	route: string,
+	error: Error,
+	now: number,
+	userContext?: Record<string, unknown>,
+	metadata?: Record<string, unknown>,
+	userAgent?: string,
+): RouteError => {
+	return Object.freeze({
+		timestamp: now,
+		route,
+		error,
+		errorType: error.name,
+		...(error.stack !== undefined && { stackTrace: error.stack }),
+		...(userAgent !== undefined && { userAgent }),
+		...(userContext !== undefined && {
+			userContext: Object.freeze(userContext),
+		}),
+		...(metadata !== undefined && { metadata: Object.freeze(metadata) }),
+	});
+};
+
+// Pure function to create error aggregation
+export const createErrorAggregation = (
+	route: string,
+	errorType: string,
+	timestamp: number,
+	userId?: string,
+): ErrorAggregation => {
+	const affectedUsers = new Set<string>();
+	if (userId) {
+		affectedUsers.add(userId);
+	}
+
+	return Object.freeze({
+		route,
+		errorType,
+		count: 1,
+		firstSeen: timestamp,
+		lastSeen: timestamp,
+		affectedUsers,
+	});
+};
+
+// Pure function to set max errors
+export const setMaxErrors = (
+	state: ErrorTrackingState,
+	max: number,
+): ErrorTrackingState => {
+	const newErrors =
+		state.errors.length > max ? state.errors.slice(-max) : state.errors;
+	return {
+		...state,
+		errors: Object.freeze(newErrors),
+		config: { ...state.config, maxErrors: max },
+	};
+};
+
+// Pure function to set max aggregations
+export const setMaxAggregations = (
+	state: ErrorTrackingState,
+	max: number,
+): ErrorTrackingState => {
+	const aggregationKeys = Object.keys(state.aggregations);
+	const newAggregations: Record<string, ErrorAggregation> = {};
+
+	// Keep only the most recent aggregations
+	for (
+		let i = Math.max(0, aggregationKeys.length - max);
+		i < aggregationKeys.length;
+		i++
+	) {
+		const key = aggregationKeys[i];
+		newAggregations[key] = state.aggregations[key];
+	}
+
+	return {
+		...state,
+		aggregations: Object.freeze(newAggregations),
+		config: { ...state.config, maxAggregations: max },
+	};
+};

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

@@ -0,0 +1,50 @@
+import type { ErrorAggregation, ErrorTrackingState } from "../models";
+
+// Pure function to clear errors
+export const clearErrors = (
+	state: ErrorTrackingState,
+	route?: string,
+): ErrorTrackingState => {
+	if (route) {
+		return {
+			...state,
+			errors: Object.freeze(state.errors.filter((e) => e.route !== route)),
+		};
+	}
+	return {
+		...state,
+		errors: Object.freeze([]),
+	};
+};
+
+// Pure function to clear aggregations
+export const clearAggregations = (
+	state: ErrorTrackingState,
+	route?: string,
+): ErrorTrackingState => {
+	if (route) {
+		const newAggregations: Record<string, ErrorAggregation> = {};
+		for (const [key, agg] of Object.entries(state.aggregations)) {
+			if (agg.route !== route) {
+				newAggregations[key] = agg;
+			}
+		}
+		return {
+			...state,
+			aggregations: Object.freeze(newAggregations),
+		};
+	}
+	return {
+		...state,
+		aggregations: Object.freeze({}),
+	};
+};
+
+// Pure function to clear all
+export const clearAll = (state: ErrorTrackingState): ErrorTrackingState => {
+	return {
+		...state,
+		errors: Object.freeze([]),
+		aggregations: Object.freeze({}),
+	};
+};

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

@@ -0,0 +1,103 @@
+import type {
+	ErrorAggregation,
+	ErrorTrackingState,
+	RouteError,
+} from "../models";
+
+// Pure function to get errors
+export const getErrors = (
+	state: ErrorTrackingState,
+	route?: string,
+): readonly RouteError[] => {
+	if (route) {
+		return state.errors.filter((e) => e.route === route);
+	}
+	return state.errors;
+};
+
+// Pure function to get errors by type
+export const getErrorsByType = (
+	state: ErrorTrackingState,
+	errorType: string,
+): readonly RouteError[] => {
+	return state.errors.filter((e) => e.errorType === errorType);
+};
+
+// Pure function to get errors in time range
+export const getErrorsInTimeRange = (
+	state: ErrorTrackingState,
+	startTime: number,
+	endTime: number,
+): readonly RouteError[] => {
+	return state.errors.filter(
+		(e) => e.timestamp >= startTime && e.timestamp <= endTime,
+	);
+};
+
+// Pure function to get aggregations
+export const getAggregations = (
+	state: ErrorTrackingState,
+): readonly ErrorAggregation[] => {
+	return Object.values(state.aggregations);
+};
+
+// Pure function to get aggregations by route
+export const getAggregationsByRoute = (
+	state: ErrorTrackingState,
+	route: string,
+): readonly ErrorAggregation[] => {
+	return getAggregations(state).filter((a) => a.route === route);
+};
+
+// Pure function to get top errors
+export const getTopErrors = (
+	state: ErrorTrackingState,
+	limit = 10,
+): readonly ErrorAggregation[] => {
+	return [...getAggregations(state)]
+		.sort((a, b) => b.count - a.count)
+		.slice(0, limit);
+};
+
+// Pure function to get error rate
+export const getErrorRate = (
+	state: ErrorTrackingState,
+	route: string,
+	now: number,
+	timeWindowMs = 60000,
+): number => {
+	const recentErrors = state.errors.filter(
+		(e) => e.route === route && e.timestamp >= now - timeWindowMs,
+	);
+	return recentErrors.length;
+};
+
+// Pure function to get error statistics
+export const getErrorStatistics = (
+	state: ErrorTrackingState,
+	now: number,
+): {
+	readonly totalErrors: number;
+	readonly uniqueRoutes: number;
+	readonly uniqueErrorTypes: number;
+	readonly topError: string | null;
+	readonly errorRate: number;
+} => {
+	const uniqueRoutes = new Set(state.errors.map((e) => e.route)).size;
+	const uniqueErrorTypes = new Set(state.errors.map((e) => e.errorType)).size;
+	const topError = getTopErrors(state, 1)[0] || null;
+
+	// Calculate error rate (errors per minute in last hour)
+	const lastHourErrors = state.errors.filter(
+		(e) => e.timestamp >= now - 3600000,
+	);
+	const errorRate = lastHourErrors.length / 60;
+
+	return {
+		totalErrors: state.errors.length,
+		uniqueRoutes,
+		uniqueErrorTypes,
+		topError: topError ? `${topError.route}:${topError.errorType}` : null,
+		errorRate,
+	};
+};

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

@@ -0,0 +1,112 @@
+import type {
+	ErrorAggregation,
+	ErrorTrackingState,
+	RouteError,
+} from "../models";
+import { createErrorAggregation, createRouteError } from "../models";
+
+// Pure function to record error
+export const recordError = (
+	state: ErrorTrackingState,
+	route: string,
+	error: Error,
+	now: number,
+	userContext?: Record<string, unknown>,
+	metadata?: Record<string, unknown>,
+	userAgent?: string,
+): ErrorTrackingState => {
+	const routeError = createRouteError(
+		route,
+		error,
+		now,
+		userContext,
+		metadata,
+		userAgent,
+	);
+
+	// Add error to list
+	const newErrors = [...state.errors, routeError];
+
+	// Keep only last maxErrors
+	const trimmedErrors =
+		newErrors.length > state.config.maxErrors
+			? newErrors.slice(-state.config.maxErrors)
+			: newErrors;
+
+	// Update aggregation
+	const newAggregations = updateAggregation(
+		state.aggregations,
+		routeError,
+		state.config.maxAggregations,
+	);
+
+	return {
+		...state,
+		errors: Object.freeze(trimmedErrors),
+		aggregations: Object.freeze(newAggregations),
+	};
+};
+
+// Helper function to update aggregation
+const updateAggregation = (
+	aggregations: Readonly<Record<string, ErrorAggregation>>,
+	error: RouteError,
+	maxAggregations: number,
+): Record<string, ErrorAggregation> => {
+	const key = `${error.route}:${error.errorType}`;
+	const existing = aggregations[key];
+
+	if (existing) {
+		const newAffectedUsers = new Set(existing.affectedUsers);
+		if (error.userContext?.userId) {
+			newAffectedUsers.add(String(error.userContext.userId));
+		}
+
+		return {
+			...aggregations,
+			[key]: Object.freeze({
+				...existing,
+				count: existing.count + 1,
+				lastSeen: error.timestamp,
+				affectedUsers: newAffectedUsers,
+			}),
+		};
+	}
+
+	const newAggregation = createErrorAggregation(
+		error.route,
+		error.errorType,
+		error.timestamp,
+		error.userContext?.userId ? String(error.userContext.userId) : undefined,
+	);
+
+	const newAggregations = { ...aggregations, [key]: newAggregation };
+
+	// Keep only last maxAggregations
+	const aggregationKeys = Object.keys(newAggregations);
+	if (aggregationKeys.length > maxAggregations) {
+		const oldestKey = getOldestAggregationKey(newAggregations);
+		if (oldestKey) {
+			delete newAggregations[oldestKey];
+		}
+	}
+
+	return newAggregations;
+};
+
+// Helper function to get oldest aggregation key
+const getOldestAggregationKey = (
+	aggregations: Record<string, ErrorAggregation>,
+): string | null => {
+	let oldestKey: string | null = null;
+	let oldestTime = Infinity;
+
+	for (const [key, agg] of Object.entries(aggregations)) {
+		if (agg.firstSeen < oldestTime) {
+			oldestTime = agg.firstSeen;
+			oldestKey = key;
+		}
+	}
+
+	return oldestKey;
+};

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

@@ -0,0 +1,55 @@
+import type { ErrorTrackingState } from "../models";
+import {
+	getAggregations,
+	getErrorStatistics,
+	getTopErrors,
+} from "./error-queries";
+
+// Pure function to generate error report
+export const generateErrorReport = (
+	state: ErrorTrackingState,
+	now: number,
+): string => {
+	const stats = getErrorStatistics(state, 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 = getTopErrors(state, 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;
+};
+
+// Pure function to export errors as JSON
+export const exportErrorsAsJSON = (
+	state: ErrorTrackingState,
+	now: number,
+): string => {
+	return JSON.stringify(
+		{
+			statistics: getErrorStatistics(state, now),
+			aggregations: getAggregations(state).map((a) => ({
+				...a,
+				affectedUsers: Array.from(a.affectedUsers),
+			})),
+			recentErrors: state.errors.slice(-50),
+		},
+		null,
+		2,
+	);
+};

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

@@ -0,0 +1,4 @@
+export * from "./error-cleanup";
+export * from "./error-queries";
+export * from "./error-recording";
+export * from "./error-reporting";

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

@@ -0,0 +1,46 @@
+import type { ErrorAggregation, RouteError } from "../models";
+
+export const validateRouteError = (error: RouteError): boolean => {
+	if (!error.route || typeof error.route !== "string") return false;
+	if (!error.error || !(error.error instanceof Error)) return false;
+	if (!error.errorType || typeof error.errorType !== "string") return false;
+	if (typeof error.timestamp !== "number" || error.timestamp < 0) return false;
+	return true;
+};
+
+export const validateErrorAggregation = (
+	aggregation: ErrorAggregation,
+): boolean => {
+	if (!aggregation.route || typeof aggregation.route !== "string") return false;
+	if (!aggregation.errorType || typeof aggregation.errorType !== "string")
+		return false;
+	if (typeof aggregation.count !== "number" || aggregation.count < 0)
+		return false;
+	if (typeof aggregation.firstSeen !== "number" || aggregation.firstSeen < 0)
+		return false;
+	if (typeof aggregation.lastSeen !== "number" || aggregation.lastSeen < 0)
+		return false;
+	if (!(aggregation.affectedUsers instanceof Set)) return false;
+	return true;
+};
+
+export const validateRoutePath = (path: string): boolean => {
+	if (!path || typeof path !== "string") return false;
+	if (!path.startsWith("/")) return false;
+	return true;
+};
+
+export const validateErrorType = (errorType: string): boolean => {
+	if (!errorType || typeof errorType !== "string") return false;
+	const validTypes = [
+		"Error",
+		"TypeError",
+		"ReferenceError",
+		"SyntaxError",
+		"RangeError",
+		"URIError",
+	];
+	return (
+		validTypes.includes(errorType) || /^[A-Z][a-zA-Z]*Error$/.test(errorType)
+	);
+};

package/src/router/modules/route-error-tracking/index.ts

@@ -0,0 +1,8 @@
+// Public API exports for route-error-tracking 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-error-tracking/ports/index.ts

@@ -0,0 +1,20 @@
+import type { RouteError } from "../types";
+
+// Port for error storage (dependency injection point)
+export interface IErrorStorage {
+	saveError(error: RouteError): Promise<void>;
+	getErrors(route?: string): Promise<RouteError[]>;
+	clearErrors(route?: string): Promise<void>;
+}
+
+// Port for error reporting (dependency injection point)
+export interface IErrorReporter {
+	sendReport(report: string): Promise<void>;
+	sendAlert(error: RouteError): Promise<void>;
+}
+
+// Port for error aggregation (dependency injection point)
+export interface IErrorAggregator {
+	aggregateErrors(errors: RouteError[]): Promise<void>;
+	getAggregations(): Promise<import("../domain/models").ErrorAggregation[]>;
+}

package/src/router/modules/route-error-tracking/types/index.ts

@@ -0,0 +1,6 @@
+export type {
+	ErrorAggregation,
+	ErrorTrackingConfig,
+	ErrorTrackingState,
+	RouteError,
+} from "../domain";

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

@@ -0,0 +1,159 @@
+import {
+	createFeatureFlag,
+	createFeatureFlagState,
+	createUserSegment,
+} from "../../domain";
+import {
+	addRouteFlag,
+	addUserSegment,
+	deleteFlag,
+	filterRoutesByFlags,
+	getAuditLog,
+	getFlag,
+	getFlagStatistics,
+	getUserSegment,
+	isEnabled,
+	isRouteEnabled,
+	setFlag,
+	toggleFlag,
+} from "../../domain/operations";
+import type {
+	AuditLogEntry,
+	FeatureFlag,
+	FeatureFlagState,
+	UserSegment,
+} from "../../types";
+
+// Use case: Set flag
+export const setFlagUseCase = (
+	state: FeatureFlagState,
+	flag: FeatureFlag,
+	now: Date,
+): FeatureFlagState => {
+	return setFlag(state, flag, now);
+};
+
+// Use case: Get flag
+export const getFlagUseCase = (
+	state: FeatureFlagState,
+	name: string,
+): FeatureFlag | undefined => {
+	return getFlag(state, name);
+};
+
+// Use case: Check if flag is enabled
+export const isEnabledUseCase = (
+	state: FeatureFlagState,
+	name: string,
+	now: Date,
+	userId?: string,
+): { readonly result: boolean; readonly state: FeatureFlagState } => {
+	return isEnabled(state, name, now, userId);
+};
+
+// Use case: Add route flag
+export const addRouteFlagUseCase = (
+	state: FeatureFlagState,
+	routePath: string,
+	flagName: string,
+): FeatureFlagState => {
+	return addRouteFlag(state, routePath, flagName);
+};
+
+// Use case: Check if route is enabled
+export const isRouteEnabledUseCase = (
+	state: FeatureFlagState,
+	routePath: string,
+	now: Date,
+	userId?: string,
+): { readonly result: boolean; readonly state: FeatureFlagState } => {
+	return isRouteEnabled(state, routePath, now, userId);
+};
+
+// Use case: Filter routes by flags
+export const filterRoutesByFlagsUseCase = (
+	state: FeatureFlagState,
+	routes: import("../../../../shared/types").RouteConfig[],
+	now: Date,
+	userId?: string,
+): import("../../../../shared/types").RouteConfig[] => {
+	return filterRoutesByFlags(state, routes, now, userId);
+};
+
+// Use case: Add user segment
+export const addUserSegmentUseCase = (
+	state: FeatureFlagState,
+	segment: UserSegment,
+): FeatureFlagState => {
+	return addUserSegment(state, segment);
+};
+
+// Use case: Get user segment
+export const getUserSegmentUseCase = (
+	state: FeatureFlagState,
+	name: string,
+): UserSegment | undefined => {
+	return getUserSegment(state, name);
+};
+
+// Use case: Get audit log
+export const getAuditLogUseCase = (
+	state: FeatureFlagState,
+	flagName?: string,
+	limit = 100,
+): readonly AuditLogEntry[] => {
+	return getAuditLog(state, flagName, limit);
+};
+
+// Use case: Get flag statistics
+export const getFlagStatisticsUseCase = (
+	state: FeatureFlagState,
+): {
+	readonly totalFlags: number;
+	readonly enabledFlags: number;
+	readonly flagsWithRollout: number;
+	readonly flagsWithConditions: number;
+} => {
+	return getFlagStatistics(state);
+};
+
+// Use case: Toggle flag
+export const toggleFlagUseCase = (
+	state: FeatureFlagState,
+	name: string,
+	now: Date,
+): { readonly result: boolean; readonly state: FeatureFlagState } => {
+	return toggleFlag(state, name, now);
+};
+
+// Use case: Delete flag
+export const deleteFlagUseCase = (
+	state: FeatureFlagState,
+	name: string,
+	now: Date,
+): { readonly result: boolean; readonly state: FeatureFlagState } => {
+	return deleteFlag(state, name, now);
+};
+
+// Use case: Create feature flag
+export const createFeatureFlagUseCase = (
+	name: string,
+	enabled: boolean,
+	options?: Partial<FeatureFlag>,
+): FeatureFlag => {
+	return createFeatureFlag(name, enabled, options);
+};
+
+// Use case: Create user segment
+export const createUserSegmentUseCase = (
+	name: string,
+	users: string[],
+	rules: ((userId: string) => boolean)[],
+): UserSegment => {
+	return createUserSegment(name, users, rules);
+};
+
+// Use case: Create feature flag state
+export const createFeatureFlagStateUseCase = (): FeatureFlagState => {
+	return createFeatureFlagState();
+};

package/src/router/modules/route-feature-flags/domain/index.ts

@@ -0,0 +1,5 @@
+// Domain layer exports
+
+export * from "./models";
+export * from "./operations";
+export * from "./validators";