@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/router/cli/route-generator-config.ts

@@ -0,0 +1,109 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { RouteTemplate } from "./route-generator-types";
+import {
+	getComponentName,
+	resolvePath,
+	writeFile,
+} from "./route-generator-utils";
+
+export const updateRouteConfig = (
+	basePath: string,
+	path: string,
+	template: RouteTemplate,
+	componentName?: string,
+	loaderName?: string,
+	guardName?: string,
+): void => {
+	const configPath = join(basePath, "..", "routes.ts");
+
+	if (!existsSync(configPath)) {
+		writeFile(
+			configPath,
+			generateInitialRouteConfig(
+				basePath,
+				path,
+				template,
+				componentName,
+				loaderName,
+				guardName,
+			),
+		);
+		return;
+	}
+
+	const existingConfig = readFileSync(configPath, "utf-8");
+	const newRoute = generateRouteConfigEntry(
+		basePath,
+		path,
+		template,
+		componentName,
+		loaderName,
+		guardName,
+	);
+
+	const updatedConfig = existingConfig.replace(
+		/(const routes = createRouteConfig\()/,
+		`$1\n  ${newRoute},`,
+	);
+
+	writeFile(configPath, updatedConfig);
+};
+
+export const generateInitialRouteConfig = (
+	basePath: string,
+	path: string,
+	template: RouteTemplate,
+	componentName?: string,
+	loaderName?: string,
+	guardName?: string,
+): string => {
+	const routeEntry = generateRouteConfigEntry(
+		basePath,
+		path,
+		template,
+		componentName,
+		loaderName,
+		guardName,
+	);
+
+	return `import { createRouteConfig } from "@wrikka/solid-framework/router";
+
+const routes = createRouteConfig([
+  ${routeEntry},
+]);
+
+export default routes;
+`;
+};
+
+export const generateRouteConfigEntry = (
+	basePath: string,
+	path: string,
+	template: RouteTemplate,
+	componentName?: string,
+	loaderName?: string,
+	guardName?: string,
+): string => {
+	const name = componentName || getComponentName(path);
+	const componentPath = resolvePath(basePath, path).replace(basePath, ".");
+
+	let config = `{
+    path: "${path}",
+    component: () => import("${componentPath}/index.tsx"),
+  `;
+
+	if (template === "with-loader" || template === "full") {
+		const loader = loaderName || `${name}Loader`;
+		config += `\n    loaders: {\n      data: () => import("${componentPath}/loader.ts").then((m) => m.${loader}()),\n    },`;
+	}
+
+	if (template === "with-guards" || template === "full") {
+		const guard = guardName || `${name}Guard`;
+		config += `\n    guards: [\n      () => import("${componentPath}/guard.ts").then((m) => m.${guard}),\n    ],`;
+	}
+
+	config += "\n  }";
+
+	return config;
+};

package/src/router/cli/route-generator-templates.ts

@@ -0,0 +1,117 @@
+import type { RouteTemplate } from "./route-generator-types";
+import { getComponentName } from "./route-generator-utils";
+
+export const getImports = (template: RouteTemplate): string => {
+	const imports = ['import { For, Show } from "solid-js"'];
+
+	if (template === "with-loader" || template === "full") {
+		imports.push(
+			'import { useRouteData } from "@wrikka/solid-framework/router"',
+		);
+	}
+
+	return imports.join("\n");
+};
+
+export const getProps = (template: RouteTemplate): string => {
+	if (template === "basic") {
+		return "";
+	}
+	return "props: any";
+};
+
+export const getHooks = (template: RouteTemplate): string => {
+	if (template === "with-loader" || template === "full") {
+		return "const data = useRouteData();";
+	}
+	return "";
+};
+
+export const getContent = (template: RouteTemplate): string => {
+	if (template === "basic") {
+		return `return (
+    <div>
+      <h1>${getComponentName("path")}</h1>
+    </div>
+  );`;
+	}
+
+	if (template === "with-loader") {
+		return `return (
+    <div>
+      <h1>${getComponentName("path")}</h1>
+      <Show when={data()} fallback={<div>Loading...</div>}>
+        {(data) => <div>{JSON.stringify(data)}</div>}
+      </Show>
+    </div>
+  );`;
+	}
+
+	if (template === "with-guards") {
+		return `return (
+    <div>
+      <h1>${getComponentName("path")}</h1>
+      <p>Protected route</p>
+    </div>
+  );`;
+	}
+
+	return `return (
+    <div>
+      <h1>${getComponentName("path")}</h1>
+      <Show when={data()} fallback={<div>Loading...</div>}>
+        {(data) => <div>{JSON.stringify(data)}</div>}
+      </Show>
+      <p>Protected route</p>
+    </div>
+  );`;
+};
+
+export const generateComponentFile = (
+	path: string,
+	template: RouteTemplate,
+	componentName?: string,
+): string => {
+	const name = componentName || getComponentName(path);
+
+	const imports = getImports(template);
+	const props = getProps(template);
+	const hooks = getHooks(template);
+	const content = getContent(template);
+
+	return `${imports}
+
+export default function ${name}(${props}) {
+  ${hooks}
+  ${content}
+}
+`;
+};
+
+export const generateLoaderFile = (
+	path: string,
+	loaderName?: string,
+): string => {
+	const name = loaderName || `${getComponentName(path)}Loader`;
+
+	return `import type { RouteParams } from "@wrikka/solid-framework/router";
+
+export async function ${name}({ params }: { params: RouteParams }) {
+  // Add your data loading logic here
+  const data = await fetch(\`/api${path}\`).then((r) => r.json());
+  return data;
+}
+`;
+};
+
+export const generateGuardFile = (path: string, guardName?: string): string => {
+	const name = guardName || `${getComponentName(path)}Guard`;
+
+	return `import { createAuthGuard } from "@wrikka/solid-framework/router";
+
+export const ${name} = createAuthGuard(() => {
+  // Add your authentication logic here
+  return localStorage.getItem("token") !== null;
+});
+`;
+};

package/src/router/cli/route-generator-types.ts

@@ -0,0 +1,9 @@
+export type RouteTemplate = "basic" | "with-loader" | "with-guards" | "full";
+
+export interface RouteGeneratorOptions {
+	path: string;
+	template: RouteTemplate;
+	componentName?: string;
+	loaderName?: string;
+	guardName?: string;
+}

package/src/router/cli/route-generator-utils.ts

@@ -0,0 +1,40 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export const resolvePath = (basePath: string, path: string): string => {
+	const normalizedPath = path
+		.split("/")
+		.filter(Boolean)
+		.map((segment) => {
+			if (segment.startsWith(":")) {
+				return `[${segment.slice(1)}]`;
+			}
+			return segment;
+		})
+		.join("/");
+
+	return join(basePath, normalizedPath);
+};
+
+export const ensureDirectory = (path: string): void => {
+	if (!existsSync(path)) {
+		mkdirSync(path, { recursive: true });
+	}
+};
+
+export const writeFile = (filePath: string, content: string): void => {
+	writeFileSync(filePath, content, "utf-8");
+};
+
+export const getComponentName = (path: string): string => {
+	const segments = path.split("/").filter(Boolean);
+	const lastSegment = segments[segments.length - 1] || "Home";
+	return pascalCase(lastSegment.replace(/:/g, ""));
+};
+
+export const pascalCase = (str: string): string => {
+	return str
+		.split(/[-_]/)
+		.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+		.join("");
+};

package/src/router/cli/route-generator.ts

@@ -0,0 +1,64 @@
+import { join } from "node:path";
+import { updateRouteConfig } from "./route-generator-config";
+import {
+	generateComponentFile,
+	generateGuardFile,
+	generateLoaderFile,
+} from "./route-generator-templates";
+import type { RouteGeneratorOptions } from "./route-generator-types";
+import {
+	ensureDirectory,
+	resolvePath,
+	writeFile,
+} from "./route-generator-utils";
+
+export type {
+	RouteGeneratorOptions,
+	RouteTemplate,
+} from "./route-generator-types";
+
+export class RouteGenerator {
+	private basePath: string;
+
+	constructor(basePath: string = "src/pages") {
+		this.basePath = basePath;
+	}
+
+	generateRoute(options: RouteGeneratorOptions): void {
+		const { path, template, componentName, loaderName, guardName } = options;
+
+		// Create directory structure
+		const fullPath = resolvePath(this.basePath, path);
+		ensureDirectory(fullPath);
+
+		// Generate component file
+		const componentFile = generateComponentFile(path, template, componentName);
+		writeFile(join(fullPath, "index.tsx"), componentFile);
+
+		// Generate loader file if needed
+		if (template === "with-loader" || template === "full") {
+			const loaderFile = generateLoaderFile(path, loaderName);
+			writeFile(join(fullPath, "loader.ts"), loaderFile);
+		}
+
+		// Generate guard file if needed
+		if (template === "with-guards" || template === "full") {
+			const guardFile = generateGuardFile(path, guardName);
+			writeFile(join(fullPath, "guard.ts"), guardFile);
+		}
+
+		// Update route config
+		updateRouteConfig(
+			this.basePath,
+			path,
+			template,
+			componentName,
+			loaderName,
+			guardName,
+		);
+	}
+}
+
+export const createRouteGenerator = (basePath?: string): RouteGenerator => {
+	return new RouteGenerator(basePath);
+};

package/src/router/index.test.ts

@@ -0,0 +1,7 @@
+import { describe, expect, it } from "vitest";
+
+describe("@wrikka/solid-framework/router", () => {
+	it("should export main functions", () => {
+		expect(true).toBe(true);
+	});
+});

package/src/router/index.ts

@@ -0,0 +1,21 @@
+// Main entry point for @wrikka/solid-framework/router
+
+export * from "./adapters";
+export * from "./modules/navigation";
+export * as RouteCache from "./modules/route-cache";
+export * as RouteErrorTracking from "./modules/route-error-tracking";
+export * as RouteFeatureFlags from "./modules/route-feature-flags";
+export * as RouteI18n from "./modules/route-i18n";
+export * as RouteNavigationTimeline from "./modules/route-navigation-timeline";
+export * as RoutePerformance from "./modules/route-performance";
+export * as RouteSecurity from "./modules/route-security";
+export * as RouteTesting from "./modules/route-testing";
+export * from "./modules/routing";
+export type { RoutePath } from "./modules/routing/domain/type-safe-links";
+// Refactored modules (Vertical Slice Architecture) - using namespace exports to avoid conflicts
+export * as RoutingCore from "./modules/routing-core";
+export * from "./presentation";
+export * from "./shared";
+export type { SolidRouterPluginOptions } from "./vite-plugin";
+// Vite Plugin
+export { solidRouterPlugin } from "./vite-plugin";

package/src/router/modules/navigation/application/index.ts

@@ -0,0 +1 @@
+export * from "./usecases";

package/src/router/modules/navigation/application/usecases.ts

@@ -0,0 +1,42 @@
+import { failure, type Result, success } from "../../../shared/types";
+import { NavigationHistory } from "../domain";
+
+export class NavigationService {
+	constructor(private history: NavigationHistory) {}
+
+	navigate(to: string, params?: Record<string, string>): Result<void> {
+		try {
+			// In real implementation, this would trigger route matching
+			this.history.navigate({
+				path: to,
+				params: params || {},
+				searchParams: {},
+			});
+			return success(undefined);
+		} catch (error) {
+			return failure(error as Error);
+		}
+	}
+
+	back(): Result<void> {
+		try {
+			this.history.back();
+			return success(undefined);
+		} catch (error) {
+			return failure(error as Error);
+		}
+	}
+
+	forward(): Result<void> {
+		try {
+			this.history.forward();
+			return success(undefined);
+		} catch (error) {
+			return failure(error as Error);
+		}
+	}
+}
+
+export const createNavigationService = (): NavigationService => {
+	return new NavigationService(new NavigationHistory());
+};

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

@@ -0,0 +1,2 @@
+export * from "./models";
+export * from "./operations";

package/src/router/modules/navigation/domain/models.ts

@@ -0,0 +1,44 @@
+import type { NavigationState } from "../types";
+
+export class NavigationHistory {
+	constructor(
+		private state: NavigationState = {
+			currentRoute: null,
+			isNavigating: false,
+			history: [],
+		},
+	) {}
+
+	get currentRoute() {
+		return this.state.currentRoute;
+	}
+
+	get isNavigating() {
+		return this.state.isNavigating;
+	}
+
+	get history() {
+		return this.state.history;
+	}
+
+	navigate(route: NavigationState["currentRoute"]): void {
+		if (this.state.currentRoute) {
+			this.state.history.push(this.state.currentRoute);
+		}
+		this.state.currentRoute = route;
+	}
+
+	back(): NavigationState["currentRoute"] | null {
+		if (this.state.history.length === 0) {
+			return null;
+		}
+		const previous = this.state.history.pop();
+		this.state.currentRoute = previous || null;
+		return previous || null;
+	}
+
+	forward(): NavigationState["currentRoute"] | null {
+		// Simplified - in real implementation would need forward history
+		return null;
+	}
+}

package/src/router/modules/navigation/domain/operations.ts

@@ -0,0 +1,28 @@
+import { failure, type Result, success } from "../../../shared/types";
+import type { NavigationAction } from "../types";
+
+export const createNavigationAction = (
+	type: NavigationAction["type"],
+	to?: string,
+	params?: Record<string, string>,
+): Result<NavigationAction> => {
+	if (type === "navigate" || type === "replace") {
+		if (!to) {
+			return failure(new Error("Route 'to' is required for navigate/replace"));
+		}
+		if (params) {
+			return success({ type, to, params });
+		}
+		return success({ type, to });
+	}
+	return success({ type });
+};
+
+export const validateNavigationAction = (
+	action: NavigationAction,
+): Result<NavigationAction> => {
+	if ((action.type === "navigate" || action.type === "replace") && !action.to) {
+		return failure(new Error("Route 'to' is required"));
+	}
+	return success(action);
+};

package/src/router/modules/navigation/index.ts

@@ -0,0 +1,3 @@
+export * from "./application";
+export * from "./domain";
+export * from "./types";

package/src/router/modules/navigation/types/index.ts

@@ -0,0 +1,15 @@
+import type { RouteMatch, RouteParams } from "../../../shared/types";
+
+export type NavigationState = {
+	currentRoute: RouteMatch | null;
+	isNavigating: boolean;
+	history: RouteMatch[];
+};
+
+export type NavigationAction =
+	| { type: "navigate"; to: string; params?: RouteParams }
+	| { type: "replace"; to: string; params?: RouteParams }
+	| { type: "back" }
+	| { type: "forward" };
+
+export type SearchState = Record<string, unknown>;

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

@@ -0,0 +1,74 @@
+import {
+	clearCache,
+	getCacheEntry,
+	getCacheStats,
+	invalidateByTag,
+	invalidateCacheEntry,
+	invalidateCachePattern,
+	setCacheEntry,
+	warmupRoutes,
+} from "../../domain/operations";
+import type { CacheState } from "../../types";
+
+// Use case: Get cached data
+export const getCachedDataUseCase = <T>(
+	state: CacheState,
+	key: string,
+	now: number,
+): T | null => {
+	return getCacheEntry<T>(state, key, now);
+};
+
+// Use case: Set cached data
+export const setCachedDataUseCase = <T>(
+	state: CacheState,
+	key: string,
+	data: T,
+	now: number,
+	ttl?: number,
+): CacheState => {
+	return setCacheEntry(state, key, data, now, ttl);
+};
+
+// Use case: Invalidate specific cache entry
+export const invalidateCacheUseCase = (
+	state: CacheState,
+	key: string,
+): CacheState => {
+	return invalidateCacheEntry(state, key);
+};
+
+// Use case: Invalidate cache by pattern
+export const invalidatePatternUseCase = (
+	state: CacheState,
+	pattern: string,
+): CacheState => {
+	return invalidateCachePattern(state, pattern);
+};
+
+// Use case: Clear all cache
+export const clearAllCacheUseCase = (state: CacheState): CacheState => {
+	return clearCache(state);
+};
+
+// Use case: Get cache statistics
+export const getCacheStatisticsUseCase = (state: CacheState, now: number) => {
+	return getCacheStats(state, now);
+};
+
+// Use case: Warmup cache for routes
+export const warmupCacheUseCase = (
+	state: CacheState,
+	routes: string[],
+	now: number,
+): CacheState => {
+	return warmupRoutes(state, routes, now);
+};
+
+// Use case: Invalidate by tag
+export const invalidateByTagUseCase = (
+	state: CacheState,
+	tag: string,
+): CacheState => {
+	return invalidateByTag(state, tag);
+};

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

@@ -0,0 +1,63 @@
+export type CacheEntry<T> = {
+	readonly data: T;
+	readonly timestamp: number;
+	readonly ttl?: number;
+	readonly metadata?: CacheMetadata;
+};
+
+export interface CacheMetadata {
+	readonly size: number;
+	readonly tags: readonly string[];
+	readonly etag?: string;
+	readonly lastModified?: number;
+}
+
+export type CacheStrategy =
+	| "memory"
+	| "swr"
+	| "stale-while-revalidate"
+	| "server-side";
+export type EvictionPolicy = "lru" | "fifo" | "lfu";
+
+export interface ServerCacheConfig {
+	readonly maxSize: number;
+	readonly evictionPolicy: EvictionPolicy;
+	readonly persistenceEnabled: boolean;
+	readonly persistencePath?: string;
+	readonly warmupEnabled: boolean;
+	readonly warmupRoutes: readonly string[];
+}
+
+export type CacheState = {
+	readonly cache: Readonly<Record<string, CacheEntry<unknown>>>;
+	readonly strategy: CacheStrategy;
+	readonly defaultTTL: number;
+	readonly serverConfig: ServerCacheConfig;
+	readonly accessOrder: readonly string[];
+	readonly accessCount: Readonly<Record<string, number>>;
+};
+
+// Pure function to create initial cache state
+export const createCacheState = (
+	strategy: CacheStrategy = "swr",
+	serverConfig?: Partial<ServerCacheConfig>,
+): CacheState => {
+	const defaultServerConfig: ServerCacheConfig = {
+		maxSize: 1000,
+		evictionPolicy: "lru",
+		persistenceEnabled: false,
+		warmupEnabled: false,
+		warmupRoutes: [],
+	};
+
+	return Object.freeze({
+		cache: Object.freeze({}),
+		strategy,
+		defaultTTL: 60000,
+		serverConfig: serverConfig
+			? { ...defaultServerConfig, ...serverConfig }
+			: defaultServerConfig,
+		accessOrder: Object.freeze([]),
+		accessCount: Object.freeze({}),
+	});
+};