@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/router/modules/routing/domain/feature-flags.ts

@@ -0,0 +1,255 @@
+import type { RouteConfig } from "../../../shared/types";
+import { evaluateTimeCondition } from "../../../shared/utils/time-condition";
+
+export interface FeatureFlagCondition {
+	type: "user-segment" | "time-based" | "custom";
+	value: unknown;
+}
+
+export type FeatureFlag = {
+	name: string;
+	enabled: boolean;
+	rolloutPercentage?: number;
+	conditions?: FeatureFlagCondition[];
+	dependencies?: string[];
+	description?: string;
+	metadata?: Record<string, unknown>;
+};
+
+export interface UserSegment {
+	name: string;
+	users: string[];
+	rules: Array<(userId: string) => boolean>;
+}
+
+export class FeatureFlagManager {
+	private flags: Map<string, FeatureFlag> = new Map();
+	private routeFlags: Map<string, string[]> = new Map();
+	private userSegments: Map<string, UserSegment> = new Map();
+	private auditLog: Array<{
+		timestamp: Date;
+		flag: string;
+		action: string;
+		userId?: string;
+		result: boolean;
+	}> = [];
+
+	setFlag(flag: FeatureFlag, now: number): void {
+		this.flags.set(flag.name, flag);
+		this.logAudit(flag.name, "set", undefined, flag.enabled, now);
+	}
+
+	getFlag(name: string): FeatureFlag | undefined {
+		return this.flags.get(name);
+	}
+
+	isEnabled(name: string, userId: string | undefined, now: number): boolean {
+		const flag = this.flags.get(name);
+		if (!flag) return false;
+
+		if (!flag.enabled) {
+			this.logAudit(name, "check", userId, false, now);
+			return false;
+		}
+
+		// Check dependencies
+		if (flag.dependencies) {
+			for (const dep of flag.dependencies) {
+				if (!this.isEnabled(dep, userId, now)) {
+					this.logAudit(name, "check", userId, false, now);
+					return false;
+				}
+			}
+		}
+
+		// Check conditions
+		if (flag.conditions && userId) {
+			for (const condition of flag.conditions) {
+				if (!this.evaluateCondition(condition, userId, now)) {
+					this.logAudit(name, "check", userId, false, now);
+					return false;
+				}
+			}
+		}
+
+		// Check rollout percentage
+		if (flag.rolloutPercentage && userId) {
+			const hash = this.hashUserId(userId);
+			const result = hash % 100 < flag.rolloutPercentage;
+			this.logAudit(name, "check", userId, result, now);
+			return result;
+		}
+
+		this.logAudit(name, "check", userId, true, now);
+		return true;
+	}
+
+	private evaluateCondition(
+		condition: FeatureFlagCondition,
+		userId: string,
+		now: number,
+	): boolean {
+		switch (condition.type) {
+			case "user-segment":
+				return this.isUserInSegment(condition.value as string, userId);
+			case "time-based":
+				return this.evaluateTimeCondition(condition.value, now);
+			case "custom":
+				// Custom conditions would be evaluated by provided functions
+				return true;
+			default:
+				return true;
+		}
+	}
+
+	private isUserInSegment(segmentName: string, userId: string): boolean {
+		const segment = this.userSegments.get(segmentName);
+		if (!segment) return false;
+
+		// Check if user is explicitly in segment
+		if (segment.users.includes(userId)) return true;
+
+		// Check segment rules
+		for (const rule of segment.rules) {
+			if (rule(userId)) return true;
+		}
+
+		return false;
+	}
+
+	private evaluateTimeCondition(value: unknown, now: number): boolean {
+		return evaluateTimeCondition(value, new Date(now));
+	}
+
+	addRouteFlag(routePath: string, flagName: string): void {
+		const existing = this.routeFlags.get(routePath) || [];
+		this.routeFlags.set(routePath, [...existing, flagName]);
+	}
+
+	isRouteEnabled(
+		routePath: string,
+		userId: string | undefined,
+		now: number,
+	): boolean {
+		const flags = this.routeFlags.get(routePath) || [];
+		return flags.every((flagName) => this.isEnabled(flagName, userId, now));
+	}
+
+	filterRoutesByFlags(
+		routes: RouteConfig[],
+		userId: string | undefined,
+		now: number,
+	): RouteConfig[] {
+		return routes.filter((route) =>
+			this.isRouteEnabled(route.path, userId, now),
+		);
+	}
+
+	addUserSegment(segment: UserSegment): void {
+		this.userSegments.set(segment.name, segment);
+	}
+
+	getUserSegment(name: string): UserSegment | undefined {
+		return this.userSegments.get(name);
+	}
+
+	private hashUserId(userId: string): number {
+		let hash = 0;
+		for (let i = 0; i < userId.length; i++) {
+			const char = userId.charCodeAt(i);
+			hash = (hash << 5) - hash + char;
+			hash = hash & hash;
+		}
+		return Math.abs(hash);
+	}
+
+	private logAudit(
+		flag: string,
+		action: string,
+		userId: string | undefined,
+		result: boolean,
+		now: number,
+	): void {
+		const logEntry: {
+			timestamp: Date;
+			flag: string;
+			action: string;
+			result: boolean;
+			userId?: string;
+		} = {
+			timestamp: new Date(now),
+			flag,
+			action,
+			result,
+		};
+
+		if (userId !== undefined) {
+			logEntry.userId = userId;
+		}
+
+		this.auditLog.push(logEntry);
+
+		// Keep only last 1000 entries
+		if (this.auditLog.length > 1000) {
+			this.auditLog = this.auditLog.slice(-1000);
+		}
+	}
+
+	getAuditLog(
+		flagName?: string,
+		limit = 100,
+	): Array<{
+		timestamp: Date;
+		flag: string;
+		action: string;
+		userId?: string;
+		result: boolean;
+	}> {
+		let logs = this.auditLog;
+
+		if (flagName) {
+			logs = logs.filter((log) => log.flag === flagName);
+		}
+
+		return logs.slice(-limit);
+	}
+
+	getFlagStatistics(): {
+		totalFlags: number;
+		enabledFlags: number;
+		flagsWithRollout: number;
+		flagsWithConditions: number;
+	} {
+		const flags = Array.from(this.flags.values());
+		return {
+			totalFlags: flags.length,
+			enabledFlags: flags.filter((f) => f.enabled).length,
+			flagsWithRollout: flags.filter((f) => f.rolloutPercentage !== undefined)
+				.length,
+			flagsWithConditions: flags.filter(
+				(f) => f.conditions && f.conditions.length > 0,
+			).length,
+		};
+	}
+
+	toggleFlag(name: string, now: number): boolean {
+		const flag = this.flags.get(name);
+		if (!flag) return false;
+
+		flag.enabled = !flag.enabled;
+		this.logAudit(name, "toggle", undefined, flag.enabled, now);
+		return true;
+	}
+
+	deleteFlag(name: string, now: number): boolean {
+		const result = this.flags.delete(name);
+		if (result) {
+			this.logAudit(name, "delete", undefined, false, now);
+		}
+		return result;
+	}
+}
+
+export const createFeatureFlagManager = (): FeatureFlagManager => {
+	return new FeatureFlagManager();
+};

package/src/router/modules/routing/domain/guards.ts

@@ -0,0 +1,104 @@
+import type { RouteMatch, RouteParams } from "../../../shared/types";
+import { failure, type Result, success } from "../../../shared/types";
+
+export type GuardResult = Result<void>;
+
+export type RouteGuard = (
+	match: RouteMatch,
+) => GuardResult | Promise<GuardResult>;
+
+export type GuardRegistry = Readonly<Record<string, readonly RouteGuard[]>>;
+
+// Pure function to add a guard
+export const addGuard = (
+	registry: GuardRegistry,
+	path: string,
+	guard: RouteGuard,
+): GuardRegistry => {
+	const existing = registry[path] || [];
+	const newRegistry: Record<string, readonly RouteGuard[]> = {
+		...registry,
+	};
+	newRegistry[path] = [...existing, guard];
+	return Object.freeze(newRegistry);
+};
+
+// Pure function to remove a guard
+export const removeGuard = (
+	registry: GuardRegistry,
+	path: string,
+	guard: RouteGuard,
+): GuardRegistry => {
+	const existing = registry[path];
+	if (!existing) return registry;
+
+	const newRegistry: Record<string, readonly RouteGuard[]> = {
+		...registry,
+	};
+	newRegistry[path] = existing.filter((g: RouteGuard) => g !== guard);
+	return Object.freeze(newRegistry);
+};
+
+// Pure function to check guards
+export const checkGuards = async (
+	registry: GuardRegistry,
+	match: RouteMatch,
+): Promise<GuardResult> => {
+	const guards = registry[match.path] || [];
+
+	for (const guard of guards) {
+		const result = await guard(match);
+		if (!result.success) {
+			return result;
+		}
+	}
+
+	return success(undefined);
+};
+
+// Pure function to create an empty guard registry
+export const createGuardRegistry = (): GuardRegistry => {
+	return Object.freeze({});
+};
+
+export const createAuthGuard = (
+	authenticate: () => boolean | Promise<boolean>,
+): RouteGuard => {
+	return async () => {
+		const isAuthenticated = await authenticate();
+		if (!isAuthenticated) {
+			return failure(new Error("Authentication required"));
+		}
+		return success(undefined);
+	};
+};
+
+export const createRoleGuard = (
+	requiredRoles: string[],
+	getUserRoles: () => string[] | Promise<string[]>,
+): RouteGuard => {
+	return async () => {
+		const userRoles = await getUserRoles();
+		const hasRequiredRole = requiredRoles.some((role) =>
+			userRoles.includes(role),
+		);
+
+		if (!hasRequiredRole) {
+			return failure(new Error("Insufficient permissions"));
+		}
+
+		return success(undefined);
+	};
+};
+
+export const createParamGuard = <T extends RouteParams>(
+	validator: (params: T) => boolean | Promise<boolean>,
+): RouteGuard => {
+	return async (match) => {
+		const isValid = await validator(match.params as T);
+		if (!isValid) {
+			return failure(new Error("Invalid parameters"));
+		}
+		return success(undefined);
+	};
+};

package/src/router/modules/routing/domain/i18n.ts

@@ -0,0 +1,230 @@
+import type { RouteConfig } from "../../../shared/types";
+
+export type Locale = string;
+export type LocaleMap = Record<Locale, string>;
+
+export interface LocaleConfig {
+	defaultLocale: Locale;
+	supportedLocales: Locale[];
+	localeDetection: "path" | "subdomain" | "header" | "cookie";
+	localeCookieName?: string;
+	localeHeaderName?: string;
+}
+
+export interface RouteTranslation {
+	path: string;
+	translations: LocaleMap;
+}
+
+export class I18nEngine {
+	private config: LocaleConfig;
+	private routeTranslations: Map<string, RouteTranslation> = new Map();
+	private currentLocale: Locale;
+
+	constructor(config: LocaleConfig) {
+		this.config = config;
+		this.currentLocale = config.defaultLocale;
+	}
+
+	setLocale(locale: Locale): void {
+		if (this.config.supportedLocales.includes(locale)) {
+			this.currentLocale = locale;
+		}
+	}
+
+	getLocale(): Locale {
+		return this.currentLocale;
+	}
+
+	getDefaultLocale(): Locale {
+		return this.config.defaultLocale;
+	}
+
+	getSupportedLocales(): Locale[] {
+		return this.config.supportedLocales;
+	}
+
+	detectLocale(path: string, headers?: Record<string, string>): Locale {
+		switch (this.config.localeDetection) {
+			case "path":
+				return this.detectFromPath(path);
+			case "header":
+				return this.detectFromHeader(headers);
+			case "cookie":
+				return this.detectFromCookie(headers);
+			case "subdomain":
+				return this.detectFromSubdomain(path);
+			default:
+				return this.config.defaultLocale;
+		}
+	}
+
+	private detectFromPath(path: string): Locale {
+		const segments = path.split("/").filter(Boolean);
+		if (segments.length > 0) {
+			const potentialLocale = segments[0];
+			if (this.config.supportedLocales.includes(potentialLocale)) {
+				return potentialLocale;
+			}
+		}
+		return this.config.defaultLocale;
+	}
+
+	private detectFromHeader(headers?: Record<string, string>): Locale {
+		if (!headers) return this.config.defaultLocale;
+
+		const acceptLanguage =
+			headers[this.config.localeHeaderName || "accept-language"];
+		if (!acceptLanguage) return this.config.defaultLocale;
+
+		const locales = acceptLanguage
+			.split(",")
+			.map((lang) => lang.split(";")[0].trim());
+
+		for (const locale of locales) {
+			if (this.config.supportedLocales.includes(locale)) {
+				return locale;
+			}
+		}
+
+		return this.config.defaultLocale;
+	}
+
+	private detectFromCookie(headers?: Record<string, string>): Locale {
+		if (!headers || !this.config.localeCookieName)
+			return this.config.defaultLocale;
+
+		const cookie = headers.cookie;
+		if (!cookie) return this.config.defaultLocale;
+
+		const cookies = cookie.split(";").map((c) => c.trim());
+		for (const c of cookies) {
+			const [name, value] = c.split("=");
+			if (name === this.config.localeCookieName) {
+				const locale = value;
+				if (this.config.supportedLocales.includes(locale)) {
+					return locale;
+				}
+			}
+		}
+
+		return this.config.defaultLocale;
+	}
+
+	private detectFromSubdomain(_path: string): Locale {
+		// This would typically be handled at the server level
+		// For now, return default locale
+		return this.config.defaultLocale;
+	}
+
+	addRouteTranslation(translation: RouteTranslation): void {
+		this.routeTranslations.set(translation.path, translation);
+	}
+
+	getRouteTranslation(path: string, locale: Locale): string | undefined {
+		const translation = this.routeTranslations.get(path);
+		if (!translation) return undefined;
+
+		return translation.translations[locale];
+	}
+
+	localizePath(path: string, locale: Locale): string {
+		// Remove existing locale prefix if present
+		const segments = path.split("/").filter(Boolean);
+		if (
+			segments.length > 0 &&
+			this.config.supportedLocales.includes(segments[0])
+		) {
+			segments.shift();
+		}
+
+		// Add new locale prefix
+		return `/${locale}/${segments.join("/")}`;
+	}
+
+	delocalizePath(path: string): string {
+		const segments = path.split("/").filter(Boolean);
+		if (
+			segments.length > 0 &&
+			this.config.supportedLocales.includes(segments[0])
+		) {
+			segments.shift();
+		}
+		return `/${segments.join("/")}`;
+	}
+
+	getLocalizedRoutes(routes: RouteConfig[], locale: Locale): RouteConfig[] {
+		return routes.map((route) => {
+			const translatedPath = this.getRouteTranslation(route.path, locale);
+			const localizedPath =
+				translatedPath || this.localizePath(route.path, locale);
+
+			return {
+				...route,
+				path: localizedPath,
+			};
+		});
+	}
+
+	getAllLocalePaths(path: string): LocaleMap {
+		const translations: LocaleMap = {};
+
+		for (const locale of this.config.supportedLocales) {
+			const translatedPath = this.getRouteTranslation(path, locale);
+			translations[locale] = translatedPath || this.localizePath(path, locale);
+		}
+
+		return translations;
+	}
+
+	formatRoute(
+		path: string,
+		params: Record<string, string>,
+		locale?: Locale,
+	): string {
+		const targetLocale = locale || this.currentLocale;
+		let localizedPath = this.localizePath(path, targetLocale);
+
+		// Replace params
+		for (const [key, value] of Object.entries(params)) {
+			localizedPath = localizedPath.replace(`:${key}`, value);
+		}
+
+		return localizedPath;
+	}
+}
+
+export const createI18nEngine = (config: LocaleConfig): I18nEngine => {
+	return new I18nEngine(config);
+};
+
+// Helper function to create locale config
+export function createLocaleConfig(
+	defaultLocale: Locale,
+	supportedLocales: Locale[],
+	options: Partial<LocaleConfig> = {},
+): LocaleConfig {
+	const config: LocaleConfig = {
+		defaultLocale,
+		supportedLocales,
+		localeDetection: options.localeDetection || "path",
+	};
+
+	if (options.localeCookieName !== undefined) {
+		config.localeCookieName = options.localeCookieName;
+	}
+
+	if (options.localeHeaderName !== undefined) {
+		config.localeHeaderName = options.localeHeaderName;
+	}
+
+	return config;
+}
+
+// Helper function to create route translation
+export function createRouteTranslation(
+	path: string,
+	translations: LocaleMap,
+): RouteTranslation {
+	return { path, translations };
+}

package/src/router/modules/routing/domain/index.ts

@@ -0,0 +1,30 @@
+export * from "./ab-testing";
+export * from "./analytics";
+export * from "./caching";
+export * from "./code-splitting";
+export * from "./contract-testing";
+export * from "./dynamic-imports";
+export * from "./e2e-testing";
+export * from "./error-boundaries";
+export * from "./error-tracking";
+export * from "./feature-flags";
+export * from "./guards";
+export * from "./i18n";
+export * from "./interactive-docs";
+export * from "./isr";
+export * from "./middleware";
+export * from "./models";
+export * from "./navigation-timeline";
+export * from "./operations";
+export * from "./optimized-matcher";
+export * from "./performance-monitoring";
+export * from "./predictive-preloading";
+export * from "./rbac";
+export * from "./resource-routes";
+export * from "./route-autocomplete";
+export * from "./route-groups";
+export * from "./security-scanner";
+export * from "./server-actions";
+export * from "./testing";
+export * from "./type-safe-links";
+export * from "./validators";