@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/stores/shared/schema-generator.ts

@@ -0,0 +1,262 @@
+// Store Module - Schema Generator
+// Clean Architecture: Generate TypeScript schemas from store state
+
+import type { Store } from "#stores/modules/store/types";
+
+// ============================================
+// SCHEMA GENERATOR TYPES
+// ============================================
+
+export interface SchemaProperty {
+	name: string;
+	type: string;
+	optional: boolean;
+	description?: string;
+	default?: unknown;
+}
+
+export interface SchemaDefinition {
+	name: string;
+	properties: SchemaProperty[];
+	description?: string;
+}
+
+export interface SchemaGeneratorOptions {
+	includeDescriptions?: boolean;
+	includeDefaults?: boolean;
+	strictNullChecks?: boolean;
+}
+
+// ============================================
+// TYPE INFERENCE
+// ============================================
+
+const inferType = (value: unknown): string => {
+	if (value === null) return "null";
+	if (value === undefined) return "undefined";
+
+	switch (typeof value) {
+		case "string":
+			return "string";
+		case "number":
+			return "number";
+		case "boolean":
+			return "boolean";
+		case "object":
+			if (Array.isArray(value)) {
+				return "unknown[]";
+			}
+			return "Record<string, unknown>";
+		default:
+			return "unknown";
+	}
+};
+
+// ============================================
+// GENERATE SCHEMA FROM STATE
+// ============================================
+
+export const generateSchema = <T extends Record<string, any>>(
+	state: T,
+	options: SchemaGeneratorOptions = {},
+): SchemaDefinition => {
+	const { includeDescriptions = false, includeDefaults = false } = options;
+
+	const properties: SchemaProperty[] = [];
+
+	for (const key in state) {
+		if (Object.hasOwn(state, key)) {
+			const value = state[key];
+			const type = inferType(value);
+
+			properties.push({
+				name: key,
+				type,
+				optional: value === undefined || value === null,
+				description: includeDescriptions ? `Property ${key}` : undefined,
+				default: includeDefaults ? value : undefined,
+			});
+		}
+	}
+
+	return {
+		name: "StoreState",
+		properties,
+		description: "Generated store state schema",
+	};
+};
+
+// ============================================
+// GENERATE TYPESCRIPT INTERFACE
+// ============================================
+
+export const generateTypeScriptInterface = (
+	schema: SchemaDefinition,
+	interfaceName = "StoreState",
+): string => {
+	const lines: string[] = [];
+
+	lines.push(`export interface ${interfaceName} {`);
+
+	for (const prop of schema.properties) {
+		const optional = prop.optional ? "?" : "";
+		const typeAnnotation = prop.type;
+		lines.push(`  ${prop.name}${optional}: ${typeAnnotation};`);
+	}
+
+	lines.push("}");
+
+	return lines.join("\n");
+};
+
+// ============================================
+// GENERATE ZOD SCHEMA
+// ============================================
+
+export const generateZodSchema = (
+	schema: SchemaDefinition,
+	variableName = "storeSchema",
+): string => {
+	const lines: string[] = [];
+
+	lines.push(`import { z } from "zod";`);
+	lines.push("");
+	lines.push(`export const ${variableName} = z.object({`);
+
+	for (const prop of schema.properties) {
+		const optional = prop.optional ? ".optional()" : "";
+		const zodType = mapTypeToZod(prop.type);
+		lines.push(`  ${prop.name}: ${zodType}${optional},`);
+	}
+
+	lines.push("});");
+
+	return lines.join("\n");
+};
+
+const mapTypeToZod = (type: string): string => {
+	switch (type) {
+		case "string":
+			return "z.string()";
+		case "number":
+			return "z.number()";
+		case "boolean":
+			return "z.boolean()";
+		case "null":
+			return "z.null()";
+		case "undefined":
+			return "z.undefined()";
+		case "unknown[]":
+			return "z.array(z.unknown())";
+		case "Record<string, unknown>":
+			return "z.record(z.unknown())";
+		default:
+			return "z.unknown()";
+	}
+};
+
+// ============================================
+// GENERATE ARKTYPE SCHEMA
+// ============================================
+
+export const generateArktypeSchema = (
+	schema: SchemaDefinition,
+	variableName = "storeSchema",
+): string => {
+	const lines: string[] = [];
+
+	lines.push(`import { type } from "arktype";`);
+	lines.push("");
+	lines.push(`export const ${variableName} = type({`);
+
+	for (const prop of schema.properties) {
+		const optional = prop.optional ? "?" : "";
+		const arktypeType = mapTypeToArktype(prop.type);
+		lines.push(`  ${prop.name}${optional}: ${arktypeType},`);
+	}
+
+	lines.push("});");
+
+	return lines.join("\n");
+};
+
+const mapTypeToArktype = (type: string): string => {
+	switch (type) {
+		case "string":
+			return "string";
+		case "number":
+			return "number";
+		case "boolean":
+			return "boolean";
+		case "null":
+			return "null";
+		case "undefined":
+			return "undefined";
+		case "unknown[]":
+			return "unknown[]";
+		case "Record<string, unknown>":
+			return "{}";
+		default:
+			return "unknown";
+	}
+};
+
+// ============================================
+// GENERATE JSON SCHEMA
+// ============================================
+
+export const generateJsonSchema = (
+	schema: SchemaDefinition,
+): Record<string, unknown> => {
+	const properties: Record<string, unknown> = {};
+	const required: string[] = [];
+
+	for (const prop of schema.properties) {
+		properties[prop.name] = {
+			type: mapTypeToJsonSchema(prop.type),
+			description: prop.description,
+			default: prop.default,
+		};
+
+		if (!prop.optional) {
+			required.push(prop.name);
+		}
+	}
+
+	return {
+		$schema: "http://json-schema.org/draft-07/schema#",
+		type: "object",
+		properties,
+		required,
+	};
+};
+
+const mapTypeToJsonSchema = (type: string): string => {
+	switch (type) {
+		case "string":
+			return "string";
+		case "number":
+			return "number";
+		case "boolean":
+			return "boolean";
+		case "null":
+			return "null";
+		case "unknown[]":
+			return "array";
+		case "Record<string, unknown>":
+			return "object";
+		default:
+			return "any";
+	}
+};
+
+// ============================================
+// GENERATE FROM STORE
+// ============================================
+
+export const generateSchemaFromStore = <T extends Record<string, any>>(
+	store: Store<T>,
+	options: SchemaGeneratorOptions = {},
+): SchemaDefinition => {
+	return generateSchema(store.getState(), options);
+};

package/src/stores/shared/types/index.ts

@@ -0,0 +1,147 @@
+// Shared Kernel - Types
+// Clean Architecture: Common types
+
+// ============================================
+// RESULT TYPE
+// ============================================
+
+export type Result<T, E = Error> =
+	| { success: true; data: T }
+	| { success: false; error: E };
+
+export const success = <T, E = Error>(data: T): Result<T, E> => ({
+	success: true,
+	data,
+});
+
+export const failure = <E>(error: E): Result<never, E> => ({
+	success: false,
+	error,
+});
+
+export const isSuccess = <T, E>(
+	result: Result<T, E>,
+): result is { success: true; data: T } => result.success;
+
+export const isFailure = <T, E>(
+	result: Result<T, E>,
+): result is { success: false; error: E } => !result.success;
+
+export const map = <T, U, E>(
+	result: Result<T, E>,
+	fn: (data: T) => U,
+): Result<U, E> =>
+	isSuccess(result) ? success<U, E>(fn(result.data)) : result;
+
+export const mapError = <T, E, F>(
+	result: Result<T, E>,
+	fn: (error: E) => F,
+): Result<T, F> => (isFailure(result) ? failure<F>(fn(result.error)) : result);
+
+export const flatMap = <T, U, E>(
+	result: Result<T, E>,
+	fn: (data: T) => Result<U, E>,
+): Result<U, E> => (isSuccess(result) ? fn(result.data) : result);
+
+export const fold = <T, E, U>(
+	result: Result<T, E>,
+	onSuccess: (data: T) => U,
+	onFailure: (error: E) => U,
+): U => (isSuccess(result) ? onSuccess(result.data) : onFailure(result.error));
+
+// ============================================
+// OPTION TYPE
+// ============================================
+
+export type Option<T> = Some<T> | None;
+
+export interface Some<T> {
+	readonly _tag: "Some";
+	readonly value: T;
+}
+
+export interface None {
+	readonly _tag: "None";
+}
+
+export const some = <T>(value: T): Option<T> => ({ _tag: "Some", value });
+
+export const none: Option<never> = { _tag: "None" };
+
+export const isSome = <T>(option: Option<T>): option is Some<T> =>
+	option._tag === "Some";
+
+export const isNone = <T>(option: Option<T>): option is None =>
+	option._tag === "None";
+
+export const mapOption = <T, U>(
+	option: Option<T>,
+	fn: (value: T) => U,
+): Option<U> => (isSome(option) ? some(fn(option.value)) : none);
+
+export const flatMapOption = <T, U>(
+	option: Option<T>,
+	fn: (value: T) => Option<U>,
+): Option<U> => (isSome(option) ? fn(option.value) : none);
+
+export const getOrElse = <T>(option: Option<T>, defaultValue: T): T =>
+	isSome(option) ? option.value : defaultValue;
+
+export const foldOption = <T, U>(
+	option: Option<T>,
+	onSome: (value: T) => U,
+	onNone: () => U,
+): U => (isSome(option) ? onSome(option.value) : onNone());
+
+// ============================================
+// EITHER TYPE
+// ============================================
+
+export type Either<L, R> = Left<L> | Right<R>;
+
+export interface Left<L> {
+	readonly _tag: "Left";
+	readonly left: L;
+}
+
+export interface Right<R> {
+	readonly _tag: "Right";
+	readonly right: R;
+}
+
+export const left = <L>(value: L): Either<L, never> => ({
+	_tag: "Left",
+	left: value,
+});
+
+export const right = <R>(value: R): Either<never, R> => ({
+	_tag: "Right",
+	right: value,
+});
+
+export const isLeft = <L, R>(either: Either<L, R>): either is Left<L> =>
+	either._tag === "Left";
+
+export const isRight = <L, R>(either: Either<L, R>): either is Right<R> =>
+	either._tag === "Right";
+
+export const mapEither = <L, R, U>(
+	either: Either<L, R>,
+	fn: (value: R) => U,
+): Either<L, U> => (isRight(either) ? right(fn(either.right)) : either);
+
+export const mapLeftEither = <L, R, M>(
+	either: Either<L, R>,
+	fn: (value: L) => M,
+): Either<M, R> => (isLeft(either) ? left(fn(either.left)) : either);
+
+export const flatMapEither = <L, R, U>(
+	either: Either<L, R>,
+	fn: (value: R) => Either<L, U>,
+): Either<L, U> => (isRight(either) ? fn(either.right) : either);
+
+export const foldEither = <L, R, U>(
+	either: Either<L, R>,
+	onLeft: (value: L) => U,
+	onRight: (value: R) => U,
+): U => (isLeft(either) ? onLeft(either.left) : onRight(either.right));

package/src/testing/index.ts

@@ -0,0 +1,90 @@
+/**
+ * Testing Utilities — @wrikka/solid-framework/testing
+ * Helpers for route-level and server-level tests without a browser
+ */
+
+import {
+	type AppServerOptions,
+	createAppServer,
+} from "#app/modules/server-entry";
+
+export { createAppServer };
+
+/**
+ * One-call route test harness — boots the real app server in-memory:
+ *
+ *   const app = testRoute({ app: App, config, fileRoutes: { manifest, modules } });
+ *   const res = await app.page("/users/42");
+ *   expectStatus(res, 200);
+ */
+export const testRoute = (options: AppServerOptions) => {
+	const handler = createAppServer(options);
+	return {
+		handler,
+		page: (path: string, init?: RequestInit) => fetchPage(handler, path, init),
+		json: <T = unknown>(path: string, init?: RequestInit) =>
+			fetchJson<T>(handler, path, init),
+	};
+};
+
+/** Fetch a path and return the parsed response parts tests assert on */
+export const fetchPage = async (
+	handler: (request: Request) => Promise<Response>,
+	path: string,
+	init?: RequestInit,
+): Promise<{ status: number; html: string; headers: Headers }> => {
+	const response = await handler(new Request(`http://test${path}`, init));
+	return {
+		status: response.status,
+		html: await response.text(),
+		headers: response.headers,
+	};
+};
+
+export const fetchJson = async <T = unknown>(
+	handler: (request: Request) => Promise<Response>,
+	path: string,
+	init?: RequestInit,
+): Promise<{ status: number; json: T; headers: Headers }> => {
+	const response = await handler(new Request(`http://test${path}`, init));
+	return {
+		status: response.status,
+		json: (await response.json()) as T,
+		headers: response.headers,
+	};
+};
+
+/** Assertion helpers matching framework conventions */
+export const expectStatus = (
+	response: { status: number },
+	expected: number,
+): void => {
+	if (response.status !== expected) {
+		throw new Error(`expected status ${expected}, got ${response.status}`);
+	}
+};
+
+export const expectHeader = (
+	response: { headers: Headers },
+	name: string,
+	expected: string | RegExp,
+): void => {
+	const actual = response.headers.get(name);
+	const ok =
+		expected instanceof RegExp
+			? expected.test(actual ?? "")
+			: actual === expected;
+	if (!ok) {
+		throw new Error(
+			`expected header ${name}=${String(expected)}, got ${actual}`,
+		);
+	}
+};
+
+export type { FxTestCtx } from "@wrikka/fx/vitest";
+/**
+ * `itFx` — vitest `it` with an fx-aware body (virtual clock, env binding,
+ * `itFx.pump` / `itFx.each` / `itFx.forAll`). Re-exported so framework
+ * tests get the effect-native test primitive next to `testRoute`.
+ */
+export { itFx } from "@wrikka/fx/vitest";

package/src/vite/auto-imports.ts

@@ -0,0 +1,65 @@
+/**
+ * Auto Imports
+ * Conservative transform: inject framework imports for configured identifiers
+ * that are used but not declared — the Nuxt auto-import equivalent
+ */
+
+export const FRAMEWORK_AUTO_IMPORTS: Record<string, string> = {
+	// head
+	Title: "@wrikka/solid-framework/head",
+	Meta: "@wrikka/solid-framework/head",
+	Link: "@wrikka/solid-framework/head",
+	useHead: "@wrikka/solid-framework/head",
+	useSeoMeta: "@wrikka/solid-framework/head",
+	// server
+	createServerFn: "@wrikka/solid-framework/server",
+	createRouteLoader: "@wrikka/solid-framework/server",
+	serverOnly: "@wrikka/solid-framework/server",
+	// actions
+	createAction: "@wrikka/solid-framework/actions",
+	useSubmission: "@wrikka/solid-framework/actions",
+	// render
+	Island: "@wrikka/solid-framework/render",
+};
+
+const escapeRegExp = (value: string): string =>
+	value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/**
+ * Returns the import statements to prepend, or null when nothing is needed.
+ * Only injects names that are (a) called/used, (b) not already imported,
+ * (c) not locally declared (const/let/function/class/import).
+ */
+export const injectAutoImports = (
+	code: string,
+	map: Record<string, string | string[]>,
+): string | null => {
+	const additions = new Map<string, Set<string>>();
+
+	for (const [name, specifier] of Object.entries(map)) {
+		// used = called/generically-typed (`name(`, `name<`) or JSX (`<Name`)
+		const used = new RegExp(
+			`(\\b${escapeRegExp(name)}\\s*[(<]|<${escapeRegExp(name)}[\\s>/])`,
+		).test(code);
+		if (!used) continue;
+
+		const declared = new RegExp(
+			`(?:import[\\s\\S]*\\b${escapeRegExp(name)}\\b[\\s\\S]*from|(?:const|let|var|function|class)\\s+${escapeRegExp(name)}\\b)`,
+		).test(code);
+		if (declared) continue;
+
+		for (const source of Array.isArray(specifier) ? specifier : [specifier]) {
+			const names = additions.get(source) ?? new Set<string>();
+			names.add(name);
+			additions.set(source, names);
+		}
+	}
+
+	if (additions.size === 0) return null;
+
+	const lines = [...additions.entries()].map(
+		([source, names]) =>
+			`import { ${[...names].sort().join(", ")} } from "${source}";`,
+	);
+	return `${lines.join("\n")}\n${code}`;
+};

package/src/vite/client.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Framework client types — virtual modules + route path union.
+ * Reference via tsconfig "types": ["@wrikka/solid-framework/vite/client"]
+ * or a triple-slash reference in env.d.ts
+ */
+
+declare module "virtual:solid-framework/config" {
+	import type { SolidFrameworkConfig } from "../app/types";
+
+	const config: SolidFrameworkConfig;
+	export default config;
+}
+
+declare module "virtual:solid-framework/routes" {
+	import type { RouteManifest, RouteModules } from "../app/modules/file-routes";
+	export const routeFiles: string[];
+	export const routeModules: RouteModules;
+	export const manifest: RouteManifest;
+	export default manifest;
+}
+
+declare module "virtual:solid-framework/server-fns" {
+	export const serverModules: Record<string, unknown>;
+	export default serverModules;
+}