@wrikka/solid-framework 0.0.0-stage → 0.15.0

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

@@ -0,0 +1,216 @@
+import type { RouteMatch, RouteParams } from "../../../../shared/types";
+import { failure, type Result, success } from "../../../../shared/types";
+
+// ============================================
+// GUARD TYPES
+// ============================================
+
+export type GuardResult = Result<void>;
+
+export type RouteGuard = (
+	match: RouteMatch,
+) => GuardResult | Promise<GuardResult>;
+
+export type GuardRegistry = Readonly<Record<string, readonly RouteGuard[]>>;
+
+// ============================================
+// RBAC TYPES
+// ============================================
+
+export interface Role {
+	readonly name: string;
+	readonly permissions: readonly string[];
+}
+
+export interface User {
+	readonly id: string;
+	readonly roles: readonly string[];
+	readonly attributes: Readonly<Record<string, unknown>>;
+}
+
+export interface Permission {
+	readonly resource: string;
+	readonly action: string;
+	readonly condition?: (user: User, context: RouteContext) => boolean;
+}
+
+export interface RouteContext {
+	readonly path: string;
+	readonly params: Readonly<Record<string, string>>;
+	readonly searchParams: Readonly<Record<string, unknown>>;
+}
+
+export interface AuditLog {
+	readonly timestamp: Date;
+	readonly userId: string;
+	readonly action: string;
+	readonly resource: string;
+	readonly result: "allowed" | "denied";
+	readonly reason?: string;
+}
+
+// ============================================
+// SECURITY STATE
+// ============================================
+
+export type SecurityState = {
+	readonly guardRegistry: GuardRegistry;
+	readonly roles: Readonly<Record<string, Role>>;
+	readonly permissions: Readonly<Record<string, Permission>>;
+	readonly routePermissions: Readonly<Record<string, readonly string[]>>;
+	readonly auditLogs: readonly AuditLog[];
+};
+
+// ============================================
+// PURE FUNCTIONS - GUARDS
+// ============================================
+
+export const createGuardRegistry = (): GuardRegistry => {
+	return Object.freeze({});
+};
+
+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);
+};
+
+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);
+};
+
+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);
+	};
+};
+
+// ============================================
+// PURE FUNCTIONS - RBAC
+// ============================================
+
+export const createSecurityState = (): SecurityState => {
+	return Object.freeze({
+		guardRegistry: createGuardRegistry(),
+		roles: Object.freeze({}),
+		permissions: Object.freeze({}),
+		routePermissions: Object.freeze({}),
+		auditLogs: Object.freeze([]),
+	});
+};
+
+export const addRole = (state: SecurityState, role: Role): SecurityState => {
+	return {
+		...state,
+		roles: {
+			...state.roles,
+			[role.name]: role,
+		},
+	};
+};
+
+export const addPermission = (
+	state: SecurityState,
+	permission: Permission,
+): SecurityState => {
+	const key = `${permission.resource}:${permission.action}`;
+	return {
+		...state,
+		permissions: {
+			...state.permissions,
+			[key]: permission,
+		},
+	};
+};
+
+export const addRoutePermission = (
+	state: SecurityState,
+	path: string,
+	permissionKey: string,
+): SecurityState => {
+	const existing = state.routePermissions[path] || [];
+	return {
+		...state,
+		routePermissions: {
+			...state.routePermissions,
+			[path]: [...existing, permissionKey],
+		},
+	};
+};
+
+export const createPermission = (
+	resource: string,
+	action: string,
+	condition?: (user: User, context: RouteContext) => boolean,
+): Permission => {
+	if (condition !== undefined) {
+		return Object.freeze({ resource, action, condition });
+	}
+	return Object.freeze({ resource, action, condition: () => true });
+};
+
+export const createRole = (name: string, permissions: string[]): Role => {
+	return Object.freeze({ name, permissions });
+};
+
+export const createUser = (
+	id: string,
+	roles: string[],
+	attributes: Record<string, unknown> = {},
+): User => {
+	return Object.freeze({ id, roles, attributes: Object.freeze(attributes) });
+};

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

@@ -0,0 +1,165 @@
+import type { RouteMatch } from "../../../../shared/types";
+import { type Result, success } from "../../../../shared/types";
+import type { AuditLog, RouteContext, SecurityState, User } from "../models";
+
+// ============================================
+// GUARD OPERATIONS
+// ============================================
+
+export const checkGuards = async (
+	state: SecurityState,
+	match: RouteMatch,
+): Promise<Result<void>> => {
+	const guards = state.guardRegistry[match.path] || [];
+
+	for (const guard of guards) {
+		const result = await guard(match);
+		if (!result.success) {
+			return result;
+		}
+	}
+
+	return success(undefined);
+};
+
+// ============================================
+// RBAC OPERATIONS
+// ============================================
+
+export const hasPermission = (
+	state: SecurityState,
+	user: User,
+	resource: string,
+	action: string,
+	context?: RouteContext,
+): boolean => {
+	const key = `${resource}:${action}`;
+	const permission = state.permissions[key];
+
+	if (!permission) {
+		return false;
+	}
+
+	// Check if user has any role with this permission
+	for (const roleName of user.roles) {
+		const role = state.roles[roleName];
+		if (role?.permissions.includes(key)) {
+			// Check condition if exists
+			if (permission.condition && context) {
+				return permission.condition(user, context);
+			}
+			return true;
+		}
+	}
+
+	return false;
+};
+
+export const canAccessRoute = (
+	state: SecurityState,
+	user: User,
+	routePath: string,
+	context: RouteContext,
+): { allowed: boolean; reason?: string } => {
+	const permissions = state.routePermissions[routePath] || [];
+
+	if (permissions.length === 0) {
+		// No permissions required - public route
+		return { allowed: true };
+	}
+
+	// Check all required permissions
+	for (const permissionKey of permissions) {
+		const [resource, action] = permissionKey.split(":");
+		if (!hasPermission(state, user, resource, action, context)) {
+			return {
+				allowed: false,
+				reason: `Missing permission: ${permissionKey}`,
+			};
+		}
+	}
+
+	return { allowed: true };
+};
+
+export const getUserRoles = (
+	_state: SecurityState,
+	user: User,
+): readonly string[] => {
+	return user.roles;
+};
+
+export const getUserPermissions = (
+	state: SecurityState,
+	user: User,
+): readonly string[] => {
+	const rolePermissions = new Set<string>();
+
+	// Collect all permissions from user's roles
+	for (const roleName of user.roles) {
+		const role = state.roles[roleName];
+		if (role) {
+			role.permissions.forEach((perm) => {
+				rolePermissions.add(perm);
+			});
+		}
+	}
+
+	return Array.from(rolePermissions);
+};
+
+// ============================================
+// AUDIT OPERATIONS
+// ============================================
+
+export const logAudit = (
+	state: SecurityState,
+	user: User,
+	action: string,
+	resource: string,
+	result: "allowed" | "denied",
+	now: number,
+	reason?: string,
+): SecurityState => {
+	const log: AuditLog = {
+		timestamp: new Date(now),
+		userId: user.id,
+		action,
+		resource,
+		result,
+		...(reason !== undefined && { reason }),
+	};
+
+	const newLogs = [...state.auditLogs, log];
+
+	// Keep only last 1000 logs
+	if (newLogs.length > 1000) {
+		newLogs.splice(0, newLogs.length - 1000);
+	}
+
+	return {
+		...state,
+		auditLogs: Object.freeze(newLogs),
+	};
+};
+
+export const getAuditLogs = (
+	state: SecurityState,
+	userId?: string,
+	limit = 100,
+): readonly AuditLog[] => {
+	let logs = state.auditLogs;
+
+	if (userId) {
+		logs = logs.filter((log) => log.userId === userId);
+	}
+
+	return logs.slice(-limit);
+};
+
+export const clearAuditLogs = (state: SecurityState): SecurityState => {
+	return {
+		...state,
+		auditLogs: Object.freeze([]),
+	};
+};

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

@@ -0,0 +1,32 @@
+import type { Permission, Role, User } from "../models";
+
+export const validateRole = (role: Role): boolean => {
+	if (!role.name || typeof role.name !== "string") return false;
+	if (!Array.isArray(role.permissions)) return false;
+	return true;
+};
+
+export const validateUser = (user: User): boolean => {
+	if (!user.id || typeof user.id !== "string") return false;
+	if (!Array.isArray(user.roles)) return false;
+	if (typeof user.attributes !== "object" || user.attributes === null)
+		return false;
+	return true;
+};
+
+export const validatePermission = (permission: Permission): boolean => {
+	if (!permission.resource || typeof permission.resource !== "string")
+		return false;
+	if (!permission.action || typeof permission.action !== "string") return false;
+	if (permission.condition && typeof permission.condition !== "function")
+		return false;
+	return true;
+};
+
+export const validateUserId = (userId: string): boolean => {
+	return typeof userId === "string" && userId.length > 0;
+};
+
+export const validateRoleName = (roleName: string): boolean => {
+	return typeof roleName === "string" && /^[a-zA-Z0-9_-]+$/.test(roleName);
+};

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

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

@@ -0,0 +1,31 @@
+import type { Permission, Role, User } from "../types";
+
+// Port for user authentication (dependency injection point)
+export interface IAuthenticator {
+	authenticate(): boolean | Promise<boolean>;
+	getCurrentUser(): User | null | Promise<User | null>;
+}
+
+// Port for role storage (dependency injection point)
+export interface IRoleStorage {
+	getRoles(): Record<string, Role>;
+	addRole(role: Role): void;
+	removeRole(roleName: string): void;
+}
+
+// Port for permission storage (dependency injection point)
+export interface IPermissionStorage {
+	getPermissions(): Record<string, Permission>;
+	addPermission(permission: Permission): void;
+	removePermission(key: string): void;
+}
+
+// Port for audit logging (dependency injection point)
+export interface IAuditLogger {
+	log(entry: import("../domain/models").AuditLog): void;
+	getLogs(
+		userId?: string,
+		limit?: number,
+	): import("../domain/models").AuditLog[];
+	clear(): void;
+}

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

@@ -0,0 +1,11 @@
+export type {
+	AuditLog,
+	GuardRegistry,
+	GuardResult,
+	Permission,
+	Role,
+	RouteContext,
+	RouteGuard,
+	SecurityState,
+	User,
+} from "../domain/models";

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

@@ -0,0 +1,131 @@
+import { createE2ETestingState, createTestingState } from "../../domain/models";
+import {
+	addTest,
+	generateTestReport,
+	getTestStatistics,
+	runAllTests,
+	runTest,
+	testAllRoutes,
+	testRouteMatch,
+	validateLoader,
+	validateMatch,
+	validateParams,
+	validateSearchParams,
+} from "../../domain/operations";
+import type {
+	E2ETest,
+	E2ETestingState,
+	RouteContract,
+	TestingState,
+} from "../../types";
+
+// Use case: Test route match
+export const testRouteMatchUseCase = (
+	state: TestingState,
+	path: string,
+): import("../../../../shared/types").Result<
+	import("../../../../shared/types").RouteMatch
+> => {
+	return testRouteMatch(state, path);
+};
+
+// Use case: Test all routes
+export const testAllRoutesUseCase = (
+	state: TestingState,
+): import("../../../../shared/types").Result<{ readonly path: string }[]> => {
+	return testAllRoutes(state);
+};
+
+// Use case: Validate params
+export const validateParamsUseCase = <
+	TParams extends import("../../../../shared/types").RouteParams,
+>(
+	contract: RouteContract<TParams>,
+	params: TParams,
+): import("../../domain/models").ContractTestResult => {
+	return validateParams(contract, params);
+};
+
+// Use case: Validate search params
+export const validateSearchParamsUseCase = (
+	contract: RouteContract,
+	searchParams: Record<string, string>,
+): import("../../domain/models").ContractTestResult => {
+	return validateSearchParams(contract, searchParams);
+};
+
+// Use case: Validate loader
+export const validateLoaderUseCase = (
+	contract: RouteContract,
+	loaderData: unknown,
+): import("../../domain/models").ContractTestResult => {
+	return validateLoader(contract, loaderData);
+};
+
+// Use case: Validate match
+export const validateMatchUseCase = <
+	TParams extends import("../../../../shared/types").RouteParams,
+>(
+	contract: RouteContract<TParams>,
+	match: import("../../../../shared/types").RouteMatch,
+): import("../../domain/models").ContractTestResult => {
+	return validateMatch(contract, match);
+};
+
+// Use case: Add E2E test
+export const addTestUseCase = (
+	state: E2ETestingState,
+	test: E2ETest,
+): E2ETestingState => {
+	return addTest(state, test);
+};
+
+// Use case: Run E2E test
+export const runTestUseCase = async (
+	test: E2ETest,
+	startTime: number,
+	endTime: number,
+): Promise<import("../../domain/models").E2ETestResult> => {
+	return runTest(test, startTime, endTime);
+};
+
+// Use case: Run all E2E tests
+export const runAllTestsUseCase = async (
+	state: E2ETestingState,
+	startTime: number,
+	endTime: number,
+): Promise<readonly import("../../domain/models").E2ETestResult[]> => {
+	return runAllTests(state, startTime, endTime);
+};
+
+// Use case: Get test statistics
+export const getTestStatisticsUseCase = (
+	results: readonly import("../../domain/models").E2ETestResult[],
+): {
+	readonly total: number;
+	readonly passed: number;
+	readonly failed: number;
+	readonly passRate: number;
+	readonly averageDuration: number;
+} => {
+	return getTestStatistics(results);
+};
+
+// Use case: Generate test report
+export const generateTestReportUseCase = (
+	results: readonly import("../../domain/models").E2ETestResult[],
+): string => {
+	return generateTestReport(results);
+};
+
+// Use case: Create testing state
+export const createTestingStateUseCase = (
+	routes: import("../../../../shared/types").RouteConfig[],
+): TestingState => {
+	return createTestingState(routes);
+};
+
+// Use case: Create E2E testing state
+export const createE2ETestingStateUseCase = (): E2ETestingState => {
+	return createE2ETestingState();
+};