@wrikka/solid-framework 0.0.0-stage → 0.15.0

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

@@ -0,0 +1,219 @@
+import type { RouteConfig } from "../../../shared/types";
+
+export interface Role {
+	name: string;
+	permissions: string[];
+}
+
+export interface User {
+	id: string;
+	roles: string[];
+	attributes: Record<string, unknown>;
+}
+
+export interface Permission {
+	resource: string;
+	action: string;
+	condition?: (user: User, context: RouteContext) => boolean;
+}
+
+export interface RouteContext {
+	path: string;
+	params: Record<string, string>;
+	searchParams: Record<string, unknown>;
+}
+
+export interface AuditLog {
+	timestamp: Date;
+	userId: string;
+	action: string;
+	resource: string;
+	result: "allowed" | "denied";
+	reason?: string;
+}
+
+export class RBACEngine {
+	private roles: Map<string, Role> = new Map();
+	private permissions: Map<string, Permission> = new Map();
+	private routePermissions: Map<string, string[]> = new Map();
+	private auditLogs: AuditLog[] = [];
+
+	addRole(role: Role): void {
+		this.roles.set(role.name, role);
+	}
+
+	addPermission(permission: Permission): void {
+		const key = `${permission.resource}:${permission.action}`;
+		this.permissions.set(key, permission);
+	}
+
+	addRoutePermission(path: string, permissionKey: string): void {
+		const existing = this.routePermissions.get(path) || [];
+		existing.push(permissionKey);
+		this.routePermissions.set(path, existing);
+	}
+
+	hasPermission(
+		user: User,
+		resource: string,
+		action: string,
+		context?: RouteContext,
+	): boolean {
+		const key = `${resource}:${action}`;
+		const permission = this.permissions.get(key);
+
+		if (!permission) {
+			return false;
+		}
+
+		// Check if user has any role with this permission
+		for (const roleName of user.roles) {
+			const role = this.roles.get(roleName);
+			if (role?.permissions.includes(key)) {
+				// Check condition if exists
+				if (permission.condition && context) {
+					return permission.condition(user, context);
+				}
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	canAccessRoute(
+		user: User,
+		route: RouteConfig,
+		context: RouteContext,
+		now: number,
+	): boolean {
+		const permissions = this.routePermissions.get(route.path) || [];
+
+		if (permissions.length === 0) {
+			// No permissions required - public route
+			return true;
+		}
+
+		// Check all required permissions
+		for (const permissionKey of permissions) {
+			const [resource, action] = permissionKey.split(":");
+			if (!this.hasPermission(user, resource, action, context)) {
+				this.logAudit(
+					user,
+					"access_route",
+					route.path,
+					"denied",
+					now,
+					`Missing permission: ${permissionKey}`,
+				);
+				return false;
+			}
+		}
+
+		this.logAudit(user, "access_route", route.path, "allowed", now);
+		return true;
+	}
+
+	getUserRoles(user: User): Role[] {
+		return user.roles
+			.map((roleName) => this.roles.get(roleName))
+			.filter((role): role is Role => role !== undefined);
+	}
+
+	getUserPermissions(user: User): Permission[] {
+		const permissions: Permission[] = [];
+		const rolePermissions = new Set<string>();
+
+		// Collect all permissions from user's roles
+		for (const roleName of user.roles) {
+			const role = this.roles.get(roleName);
+			if (role) {
+				role.permissions.forEach((perm) => {
+					rolePermissions.add(perm);
+				});
+			}
+		}
+
+		// Get permission objects
+		for (const permKey of rolePermissions) {
+			const permission = this.permissions.get(permKey);
+			if (permission) {
+				permissions.push(permission);
+			}
+		}
+
+		return permissions;
+	}
+
+	private logAudit(
+		user: User,
+		action: string,
+		resource: string,
+		result: "allowed" | "denied",
+		now: number,
+		reason?: string,
+	): void {
+		const log: AuditLog = {
+			timestamp: new Date(now),
+			userId: user.id,
+			action,
+			resource,
+			result,
+		};
+
+		if (reason !== undefined) {
+			log.reason = reason;
+		}
+
+		this.auditLogs.push(log);
+
+		// Keep only last 1000 logs
+		if (this.auditLogs.length > 1000) {
+			this.auditLogs = this.auditLogs.slice(-1000);
+		}
+	}
+
+	getAuditLogs(userId?: string, limit = 100): AuditLog[] {
+		let logs = this.auditLogs;
+
+		if (userId) {
+			logs = logs.filter((log) => log.userId === userId);
+		}
+
+		return logs.slice(-limit);
+	}
+
+	clearAuditLogs(): void {
+		this.auditLogs = [];
+	}
+}
+
+export const createRBACEngine = (): RBACEngine => {
+	return new RBACEngine();
+};
+
+// Helper function to create a permission
+export function createPermission(
+	resource: string,
+	action: string,
+	condition?: (user: User, context: RouteContext) => boolean,
+): Permission {
+	if (condition !== undefined) {
+		return { resource, action, condition };
+	}
+	return { resource, action, condition: () => true };
+}
+
+// Helper function to create a role
+export function createRole(name: string, permissions: string[]): Role {
+	return { name, permissions };
+}
+
+// Helper function to create a user
+export function createUser(
+	id: string,
+	roles: string[],
+	attributes: Record<string, unknown> = {},
+): User {
+	return { id, roles, attributes };
+}

package/src/router/modules/routing/domain/resource-routes.ts

@@ -0,0 +1,64 @@
+import { failure, type Result, success } from "../../../shared/types";
+
+export type ResourceRoute = {
+	path: string;
+	handler: (request: Request) => Promise<Response>;
+	methods?: string[];
+};
+
+export class ResourceRouteManager {
+	private resourceRoutes: Map<string, ResourceRoute> = new Map();
+
+	addResourceRoute(route: ResourceRoute): void {
+		this.resourceRoutes.set(route.path, route);
+	}
+
+	getResourceRoute(path: string): ResourceRoute | undefined {
+		return this.resourceRoutes.get(path);
+	}
+
+	async handleRequest(
+		path: string,
+		request: Request,
+	): Promise<Result<Response>> {
+		const route = this.resourceRoutes.get(path);
+
+		if (!route) {
+			return failure(new Error(`No resource route found for: ${path}`));
+		}
+
+		if (route.methods && !route.methods.includes(request.method)) {
+			return failure(
+				new Error(`Method ${request.method} not allowed for ${path}`),
+			);
+		}
+
+		try {
+			const response = await route.handler(request);
+			return success(response);
+		} catch (error) {
+			return failure(error as Error);
+		}
+	}
+
+	getAllResourceRoutes(): ResourceRoute[] {
+		return Array.from(this.resourceRoutes.values());
+	}
+}
+
+export const createResourceRouteManager = (): ResourceRouteManager => {
+	return new ResourceRouteManager();
+};
+
+export const createResourceRoute = (
+	path: string,
+	handler: (request: Request) => Promise<Response>,
+	methods?: string[],
+): ResourceRoute => {
+	const route: ResourceRoute = {
+		path,
+		handler,
+	};
+	if (methods) route.methods = methods;
+	return route;
+};

package/src/router/modules/routing/domain/route-autocomplete.ts

@@ -0,0 +1,176 @@
+import type { RouteConfig, RouteParams } from "../../../shared/types";
+
+export interface RouteSuggestion {
+	path: string;
+	params: string[];
+	description?: string;
+	priority: number;
+}
+
+export interface AutocompleteContext {
+	currentPath: string;
+	cursorPosition: number;
+	routes: RouteConfig[];
+}
+
+export class RouteAutocomplete {
+	private routes: RouteConfig[];
+	private routeDescriptions: Map<string, string> = new Map();
+
+	constructor(routes: RouteConfig[]) {
+		this.routes = routes;
+	}
+
+	setRouteDescription(path: string, description: string): void {
+		this.routeDescriptions.set(path, description);
+	}
+
+	getSuggestions(context: AutocompleteContext): RouteSuggestion[] {
+		const suggestions: RouteSuggestion[] = [];
+		const { currentPath, cursorPosition } = context;
+
+		// Extract the current input up to cursor
+		const currentInput = currentPath.slice(0, cursorPosition);
+
+		// Match routes that start with the current input
+		for (const route of this.routes) {
+			if (route.path.startsWith(currentInput)) {
+				const params = this.extractParams(route.path);
+				const description = this.routeDescriptions.get(route.path);
+
+				const suggestion: RouteSuggestion = {
+					path: route.path,
+					params,
+					priority: this.calculatePriority(route.path, currentInput),
+				};
+
+				if (description !== undefined) {
+					suggestion.description = description;
+				}
+
+				suggestions.push(suggestion);
+			}
+		}
+
+		// Sort by priority
+		return suggestions.sort((a, b) => b.priority - a.priority);
+	}
+
+	private extractParams(path: string): string[] {
+		const params: string[] = [];
+		const segments = path.split("/");
+
+		for (const segment of segments) {
+			if (segment.startsWith(":")) {
+				params.push(segment.slice(1));
+			}
+		}
+
+		return params;
+	}
+
+	private calculatePriority(routePath: string, currentInput: string): number {
+		let priority = 0;
+
+		// Exact match gets highest priority
+		if (routePath === currentInput) {
+			priority += 100;
+		}
+
+		// Shorter routes get higher priority
+		priority += 100 - routePath.length;
+
+		// Routes with fewer params get higher priority
+		const paramCount = (routePath.match(/:/g) || []).length;
+		priority -= paramCount * 10;
+
+		return priority;
+	}
+
+	completeRoute(
+		currentPath: string,
+		cursorPosition: number,
+		selectedSuggestion: RouteSuggestion,
+	): string {
+		const currentInput = currentPath.slice(0, cursorPosition);
+		const remainingPath = selectedSuggestion.path.slice(currentInput.length);
+
+		return currentPath.slice(0, cursorPosition) + remainingPath;
+	}
+
+	generateTypeDefinition(): string {
+		let definition = "// Auto-generated route type definitions\n\n";
+
+		for (const route of this.routes) {
+			const params = this.extractParams(route.path);
+			const typeName = this.pathToTypeName(route.path);
+
+			if (params.length > 0) {
+				definition += `export type ${typeName}Params = {\n`;
+				for (const param of params) {
+					definition += `  ${param}: string;\n`;
+				}
+				definition += `};\n\n`;
+			}
+		}
+
+		return definition;
+	}
+
+	private pathToTypeName(path: string): string {
+		return path
+			.split("/")
+			.map((segment) => {
+				if (segment.startsWith(":")) {
+					return segment.slice(1).toUpperCase();
+				}
+				return segment.charAt(0).toUpperCase() + segment.slice(1);
+			})
+			.join("");
+	}
+
+	getRouteForPath(path: string): RouteConfig | undefined {
+		return this.routes.find((route) => route.path === path);
+	}
+
+	validateParams(path: string, params: RouteParams): boolean {
+		const route = this.getRouteForPath(path);
+		if (!route) return false;
+
+		const requiredParams = this.extractParams(route.path);
+		for (const param of requiredParams) {
+			if (!(param in params)) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	getMissingParams(path: string, params: RouteParams): string[] {
+		const route = this.getRouteForPath(path);
+		if (!route) return [];
+
+		const requiredParams = this.extractParams(route.path);
+		return requiredParams.filter((param) => !(param in params));
+	}
+}
+
+export const createRouteAutocomplete = (
+	routes: RouteConfig[],
+): RouteAutocomplete => {
+	return new RouteAutocomplete(routes);
+};
+
+// Helper function to create autocomplete context
+export function createAutocompleteContext(
+	currentPath: string,
+	cursorPosition: number,
+	routes: RouteConfig[],
+): AutocompleteContext {
+	return {
+		currentPath,
+		cursorPosition,
+		routes,
+	};
+}

package/src/router/modules/routing/domain/route-groups.ts

@@ -0,0 +1,63 @@
+import type { RouteConfig } from "../../../shared/types";
+
+export type RouteGroup = {
+	name: string;
+	prefix: string;
+	routes: RouteConfig[];
+	middleware?: string[];
+};
+
+export class RouteGroupManager {
+	private groups: Map<string, RouteGroup> = new Map();
+
+	addGroup(group: RouteGroup): void {
+		this.groups.set(group.name, group);
+	}
+
+	getGroup(name: string): RouteGroup | undefined {
+		return this.groups.get(name);
+	}
+
+	getRoutesByGroup(name: string): RouteConfig[] {
+		const group = this.groups.get(name);
+		return group?.routes || [];
+	}
+
+	flattenRoutes(): RouteConfig[] {
+		const routes: RouteConfig[] = [];
+
+		for (const group of this.groups.values()) {
+			for (const route of group.routes) {
+				routes.push({
+					...route,
+					path: `${group.prefix}${route.path}`,
+				});
+			}
+		}
+
+		return routes;
+	}
+
+	getAllGroups(): RouteGroup[] {
+		return Array.from(this.groups.values());
+	}
+}
+
+export const createRouteGroupManager = (): RouteGroupManager => {
+	return new RouteGroupManager();
+};
+
+export const createRouteGroup = (
+	name: string,
+	prefix: string,
+	routes: RouteConfig[],
+	middleware?: string[],
+): RouteGroup => {
+	const group: RouteGroup = {
+		name,
+		prefix,
+		routes,
+	};
+	if (middleware) group.middleware = middleware;
+	return group;
+};