@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/hooks/shared/utils/logger.ts

@@ -0,0 +1,69 @@
+// Simple logger utility for composables
+
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export interface LoggerOptions {
+	level?: LogLevel;
+}
+
+const DEFAULT_LEVEL: LogLevel = "info";
+
+const LEVEL_PRIORITY: Record<LogLevel, number> = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3,
+};
+
+let currentLevel: LogLevel = DEFAULT_LEVEL;
+
+export function setLogLevel(level: LogLevel): void {
+	currentLevel = level;
+}
+
+export function log(
+	level: LogLevel,
+	message: string,
+	...args: unknown[]
+): void {
+	if (LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[currentLevel]) {
+		console[level](`[${level.toUpperCase()}]`, message, ...args);
+	}
+}
+
+export function logDebug(message: string, ...args: unknown[]): void {
+	log("debug", message, ...args);
+}
+
+export function logInfo(message: string, ...args: unknown[]): void {
+	log("info", message, ...args);
+}
+
+export function logWarn(message: string, ...args: unknown[]): void {
+	log("warn", message, ...args);
+}
+
+export function logError(message: string, ...args: unknown[]): void {
+	log("error", message, ...args);
+}
+
+// Async operation logging
+export async function logAsyncOperation<T>(
+	operation: string,
+	fn: () => Promise<T>,
+): Promise<T> {
+	logInfo(`Starting: ${operation}`);
+	try {
+		const result = await fn();
+		logInfo(`Completed: ${operation}`);
+		return result;
+	} catch (error) {
+		logError(`Failed: ${operation}`, error);
+		throw error;
+	}
+}
+
+// Side effect logging
+export function logSideEffect(effect: string, ...args: unknown[]): void {
+	logInfo(`Side effect: ${effect}`, ...args);
+}

package/src/hooks/shared/utils/pipe.ts

@@ -0,0 +1,5 @@
+// Pipe utility for function composition
+export const pipe =
+	<T>(...fns: Array<(arg: T) => T>) =>
+	(value: T): T =>
+		fns.reduce((acc, fn) => fn(acc), value);

package/src/hooks/shared/utils/result.ts

@@ -0,0 +1,9 @@
+// Result type utilities - re-exports from types/result
+import { chain, failure, resultMap, success } from "../types/result";
+
+export type { Result } from "../types/result";
+
+export const ok = success;
+export const err = failure;
+export const map = resultMap;
+export { chain };

package/src/hooks/test/counter.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import {
+	createCounterEntity,
+	decrementCounter,
+	incrementCounter,
+} from "../modules/counter/domain/operations";
+
+describe("counter domain", () => {
+	it("creates a counter with default value", () => {
+		const counter = createCounterEntity({});
+		expect(counter.value).toBe(0);
+	});
+
+	it("increments the counter", () => {
+		const counter = createCounterEntity({ initialValue: 5 });
+		const next = incrementCounter(counter);
+		expect(next.value).toBe(6);
+	});
+
+	it("decrements the counter", () => {
+		const counter = createCounterEntity({ initialValue: 5 });
+		const next = decrementCounter(counter);
+		expect(next.value).toBe(4);
+	});
+});

package/src/index.ts

@@ -0,0 +1,16 @@
+// @wrikka/solid-framework - Public API
+// Namespaced domain exports to avoid symbol collisions across domains.
+
+export * as actions from "./actions";
+export * as app from "./app";
+export * as assets from "./assets";
+export * as devtools from "./devtools";
+export * as head from "./head";
+export * as hooks from "./hooks";
+export * as query from "./query";
+export * as render from "./render";
+export * as router from "./router";
+export * as server from "./server";
+export * as stores from "./stores";
+// cli and vite are tooling domains — import via subpaths:
+//   @wrikka/solid-framework/vite, @wrikka/solid-framework/cli

package/src/internal.ts

@@ -0,0 +1,61 @@
+// Internal plumbing — @wrikka/solid-framework/internal
+// Advanced/runtime-facing exports kept out of the main /app surface.
+// Semver-exempt: internals may change in minor releases.
+
+export { createRouteActionHandler } from "./app/modules/file-routes/domain/operations/actions";
+export { createApiRouteHandler } from "./app/modules/file-routes/domain/operations/api";
+export {
+	generateApiTypes,
+	generateRouteTypes,
+} from "./app/modules/file-routes/domain/operations/codegen";
+export {
+	DEFER_MARKER,
+	DEFERRED,
+	deferMarkerKey,
+	deferResolveScript,
+	deferredRegistry,
+	extractDeferred,
+	isDeferred,
+	materializeDeferred,
+	readDeferredRegistry,
+	resolveDeferred,
+} from "./app/modules/file-routes/domain/operations/defer";
+export {
+	createLoaderHandler,
+	isLoaderRequest,
+	LOADER_ENDPOINT,
+	type LoaderContext,
+	type RouteLoaderFn,
+	runFileRouteLoader,
+} from "./app/modules/file-routes/domain/operations/loader";
+export { buildRouteManifest } from "./app/modules/file-routes/domain/operations/manifest";
+export {
+	matchFileRoute,
+	routePaths,
+} from "./app/modules/file-routes/domain/operations/match";
+export { expandStaticRoutes } from "./app/modules/file-routes/domain/operations/static-params";
+export {
+	clearDevEvents,
+	devEvents,
+	recordDevEvent,
+	startDevSpan,
+	timedDevEvent,
+	updateDevEvent,
+} from "./app/modules/file-routes/presentation/dev-events";
+export { PrefetchContext } from "./app/modules/file-routes/presentation/Link";
+export {
+	HydrationContext,
+	LoaderDataContext,
+	LoaderRetryContext,
+	readHydrated,
+} from "./app/modules/file-routes/presentation/loader-data";
+export {
+	createLocation,
+	LocationContext,
+	ParamsContext,
+	RequestContext,
+	RouteStateContext,
+	SearchContext,
+} from "./app/modules/file-routes/presentation/location";
+export { preloadFileRoute } from "./app/modules/file-routes/presentation/route-modules";
+export { RouteStatusContext } from "./app/modules/file-routes/presentation/status";

package/src/query/adapters/devtools/index.ts

@@ -0,0 +1,29 @@
+import type { QueryDevtoolsPort } from "#query/modules/query/ports";
+
+export type { QueryDevtoolsPort };
+
+export const consoleDevtools = (): QueryDevtoolsPort => ({
+	name: "console",
+	onQueryAdded: (query) => {
+		console.log("[Query] added", query.queryHash, query.getState());
+	},
+	onQueryUpdated: (query) => {
+		console.log("[Query] updated", query.queryHash, query.getState());
+	},
+	onQueryRemoved: (query) => {
+		console.log("[Query] removed", query.queryHash);
+	},
+	onMutationAdded: (mutation) => {
+		console.log("[Mutation] added", mutation.mutationHash, mutation.getState());
+	},
+	onMutationUpdated: (mutation) => {
+		console.log(
+			"[Mutation] updated",
+			mutation.mutationHash,
+			mutation.getState(),
+		);
+	},
+	onMutationRemoved: (mutation) => {
+		console.log("[Mutation] removed", mutation.mutationHash);
+	},
+});

package/src/query/adapters/persistence/index.ts

@@ -0,0 +1,62 @@
+import type { QueryKey, QueryPersistencePort } from "#query/modules/query";
+
+export type { QueryPersistencePort };
+
+export const createMemoryPersistence = (): QueryPersistencePort => {
+	const cache = new Map<string, unknown>();
+
+	const keyToString = (key: QueryKey): string => JSON.stringify(key);
+
+	return {
+		name: "memory",
+		getItem<T>(key: QueryKey): T | undefined {
+			return cache.get(keyToString(key)) as T | undefined;
+		},
+		setItem(key: QueryKey, value: unknown): void {
+			cache.set(keyToString(key), value);
+		},
+		removeItem(key: QueryKey): void {
+			cache.delete(keyToString(key));
+		},
+	};
+};
+
+export const createLocalStoragePersistence = (
+	key = "@wrikka/solid-framework/query",
+): QueryPersistencePort => {
+	if (typeof localStorage === "undefined") {
+		return createMemoryPersistence();
+	}
+
+	const read = (): Record<string, unknown> => {
+		const raw = localStorage.getItem(key);
+		if (!raw) return {};
+		try {
+			return JSON.parse(raw) as Record<string, unknown>;
+		} catch {
+			return {};
+		}
+	};
+
+	const write = (cache: Record<string, unknown>): void => {
+		localStorage.setItem(key, JSON.stringify(cache));
+	};
+
+	return {
+		name: "localStorage",
+		getItem<T>(key: QueryKey): T | undefined {
+			const cache = read();
+			return cache[JSON.stringify(key)] as T | undefined;
+		},
+		setItem(key: QueryKey, value: unknown): void {
+			const cache = read();
+			cache[JSON.stringify(key)] = value;
+			write(cache);
+		},
+		removeItem(key: QueryKey): void {
+			const cache = read();
+			delete cache[JSON.stringify(key)];
+			write(cache);
+		},
+	};
+};

package/src/query/adapters/solid/index.ts

@@ -0,0 +1,10 @@
+export {
+	isSkipToken,
+	QueryClientProvider,
+	type SkipToken,
+	skipToken,
+	useQueryClient,
+} from "./solid-query-context";
+export { useInfiniteQuery as createInfiniteQuery } from "./solid-query-use-infinite";
+export { useMutation as createMutation } from "./solid-query-use-mutation";
+export { useQuery as createQuery } from "./solid-query-use-query";

package/src/query/adapters/solid/solid-query-context.ts

@@ -0,0 +1,29 @@
+import type { FlowComponent } from "solid-js";
+import { createComponent, createContext, useContext } from "solid-js";
+import type { QueryClient } from "#query/modules/query";
+
+export const skipToken = Symbol.for("@wrikka/solid-framework/query/skipToken");
+
+export type SkipToken = typeof skipToken;
+
+export const isSkipToken = (value: unknown): value is SkipToken =>
+	value === skipToken;
+
+const QueryClientContext = createContext<QueryClient | undefined>(undefined);
+
+export const QueryClientProvider: FlowComponent<{ client: QueryClient }> = (
+	props,
+) => {
+	return createComponent(QueryClientContext.Provider, {
+		value: props.client,
+		get children() {
+			return props.children;
+		},
+	});
+};
+
+export const useQueryClient = (): QueryClient => {
+	const client = useContext(QueryClientContext);
+	if (!client) throw new Error("No QueryClient set");
+	return client;
+};

package/src/query/adapters/solid/solid-query-empty-result.ts

@@ -0,0 +1,34 @@
+import type {
+	InfiniteData,
+	InfiniteQueryObserverResult,
+} from "#query/modules/query/types";
+
+export const createEmptyInfiniteResult = <
+	TData,
+	TError,
+	TSelected,
+>(): InfiniteQueryObserverResult<TData, TError, TSelected> =>
+	({
+		data: { pages: [], pageParams: [] } as unknown as InfiniteData<TSelected>,
+		dataUpdatedAt: 0,
+		error: null,
+		errorUpdatedAt: 0,
+		failureCount: 0,
+		failureReason: null,
+		fetchStatus: "idle",
+		status: "pending",
+		isLoading: false,
+		isFetching: false,
+		isPending: true,
+		isSuccess: false,
+		isError: false,
+		isInitialLoading: false,
+		isStale: true,
+		hasNextPage: false,
+		hasPreviousPage: false,
+		isFetchingNextPage: false,
+		isFetchingPreviousPage: false,
+		fetchNextPage: () => Promise.resolve(),
+		fetchPreviousPage: () => Promise.resolve(),
+		refetch: () => Promise.resolve(),
+	}) as unknown as InfiniteQueryObserverResult<TData, TError, TSelected>;

package/src/query/adapters/solid/solid-query-options.ts

@@ -0,0 +1,52 @@
+import type {
+	InfiniteQueryOptions,
+	MutationOptions,
+	QueryClient,
+	QueryOptions,
+} from "#query/modules/query";
+import { type SkipToken, skipToken } from "./solid-query-context";
+
+export const mergeQueryOptions = <TData, TError, TSelected>(
+	client: QueryClient,
+	options: QueryOptions<TData, TError, TSelected>,
+): QueryOptions<TData, TError, TSelected> =>
+	({
+		...client.defaultOptions.queries,
+		...options,
+	}) as QueryOptions<TData, TError, TSelected>;
+
+export const resolveQueryOptions = <TData, TError, TSelected>(
+	client: QueryClient,
+	raw: QueryOptions<TData, TError, TSelected> | SkipToken,
+): QueryOptions<TData, TError, TSelected> => {
+	if (isSkipToken(raw)) {
+		return {
+			queryKey: [skipToken],
+			queryFn: async () => {
+				throw new Error("skipToken");
+			},
+			enabled: false,
+		} as unknown as QueryOptions<TData, TError, TSelected>;
+	}
+	return mergeQueryOptions(client, raw);
+};
+
+const isSkipToken = (value: unknown): value is SkipToken => value === skipToken;
+
+export const mergeMutationOptions = <TData, TError, TVariables, TContext>(
+	client: QueryClient,
+	options: MutationOptions<TData, TError, TVariables, TContext>,
+): MutationOptions<TData, TError, TVariables, TContext> =>
+	({
+		...client.defaultOptions.mutations,
+		...options,
+	}) as MutationOptions<TData, TError, TVariables, TContext>;
+
+export const mergeInfiniteOptions = <TData, TError, TSelected>(
+	client: QueryClient,
+	options: InfiniteQueryOptions<TData, TError, TSelected>,
+): InfiniteQueryOptions<TData, TError, TSelected> =>
+	({
+		...client.defaultOptions.queries,
+		...options,
+	}) as unknown as InfiniteQueryOptions<TData, TError, TSelected>;

package/src/query/adapters/solid/solid-query-use-infinite.ts

@@ -0,0 +1,228 @@
+import type { Accessor } from "solid-js";
+import { createEffect, onCleanup } from "solid-js";
+import { createStore } from "solid-js/store";
+import { hashKey } from "#query/modules/query/domain/operations";
+import type {
+	InfiniteData,
+	InfiniteQueryObserverResult,
+	InfiniteQueryOptions,
+	QueryFunctionContext,
+	QueryOptions,
+} from "#query/modules/query/types";
+import { useQueryClient } from "./solid-query-context";
+import { createEmptyInfiniteResult } from "./solid-query-empty-result";
+import { mergeInfiniteOptions } from "./solid-query-options";
+
+export function useInfiniteQuery<
+	TData = unknown,
+	TError = Error,
+	TSelected = TData,
+>(
+	optionsAccessor: Accessor<InfiniteQueryOptions<TData, TError, TSelected>>,
+): InfiniteQueryObserverResult<TData, TError, TSelected> {
+	const client = useQueryClient();
+
+	const [result, setResult] = createStore<
+		InfiniteQueryObserverResult<TData, TError, TSelected>
+	>(createEmptyInfiniteResult());
+
+	let currentOptions = mergeInfiniteOptions(client, optionsAccessor());
+	let pages: TData[] = [];
+	let pageParams: unknown[] = [];
+	let currentError: TError | null = null;
+
+	const selectedData = (data: InfiniteData<TData>): InfiniteData<TSelected> => {
+		return currentOptions.select
+			? (currentOptions.select(data) as unknown as InfiniteData<TSelected>)
+			: (data as unknown as InfiniteData<TSelected>);
+	};
+
+	const buildResult = (
+		status: "pending" | "error" | "success",
+		fetchStatus: "idle" | "fetching" | "paused",
+		flags: { all: boolean; next: boolean; prev: boolean },
+	): InfiniteQueryObserverResult<TData, TError, TSelected> => {
+		const data: InfiniteData<TData> = { pages, pageParams };
+		const hasNextPage =
+			pages.length > 0
+				? currentOptions.getNextPageParam(pages[pages.length - 1], pages) !==
+					undefined
+				: false;
+		const hasPreviousPage =
+			pages.length > 0 && currentOptions.getPreviousPageParam
+				? currentOptions.getPreviousPageParam(pages[0], pages) !== undefined
+				: false;
+		const isLoading = status === "pending" && fetchStatus === "fetching";
+
+		return {
+			data: selectedData(data),
+			dataUpdatedAt: client.clock(),
+			error: currentError,
+			errorUpdatedAt: currentError ? client.clock() : 0,
+			failureCount: 0,
+			failureReason: currentError,
+			fetchStatus,
+			status,
+			isLoading,
+			isFetching: fetchStatus === "fetching",
+			isPending: status === "pending",
+			isSuccess: status === "success",
+			isError: status === "error",
+			isInitialLoading: isLoading,
+			isStale: status === "pending" || !pages.length,
+			hasNextPage,
+			hasPreviousPage,
+			isFetchingNextPage: flags.next,
+			isFetchingPreviousPage: flags.prev,
+			refetch,
+			fetchNextPage,
+			fetchPreviousPage,
+		} as unknown as InfiniteQueryObserverResult<TData, TError, TSelected>;
+	};
+
+	const updateStore = (
+		status: "pending" | "error" | "success",
+		fetchStatus: "idle" | "fetching" | "paused",
+		flags: { all: boolean; next: boolean; prev: boolean },
+	) => {
+		setResult(
+			buildResult(status, fetchStatus, flags) as unknown as typeof result,
+		);
+	};
+
+	const fetchPage = async (pageParam: unknown): Promise<TData> => {
+		return client.fetchQuery<TData, TError, TData>({
+			queryKey: [...currentOptions.queryKey, pageParam],
+			queryFn: (baseCtx: QueryFunctionContext) =>
+				currentOptions.queryFn({ ...baseCtx, pageParam }),
+			staleTime: currentOptions.staleTime,
+			gcTime: currentOptions.gcTime,
+			retry: currentOptions.retry,
+			retryDelay: currentOptions.retryDelay,
+			networkMode: currentOptions.networkMode,
+			meta: currentOptions.meta,
+		} as QueryOptions<TData, TError, TData>);
+	};
+
+	const initialize = async () => {
+		updateStore("pending", "fetching", { all: true, next: false, prev: false });
+		try {
+			const page = await fetchPage(currentOptions.initialPageParam);
+			pages = [page];
+			pageParams = [currentOptions.initialPageParam];
+			currentError = null;
+			updateStore("success", "idle", { all: false, next: false, prev: false });
+		} catch (error) {
+			currentError = (
+				error instanceof Error ? error : new Error(String(error))
+			) as TError;
+			updateStore("error", "idle", { all: false, next: false, prev: false });
+		}
+	};
+
+	const refetch = async () => {
+		updateStore(result.status, "fetching", {
+			all: true,
+			next: false,
+			prev: false,
+		});
+		const newPages: TData[] = [];
+		try {
+			for (const pageParam of pageParams) {
+				newPages.push(await fetchPage(pageParam));
+			}
+			pages = newPages;
+			currentError = null;
+			updateStore("success", "idle", { all: false, next: false, prev: false });
+		} catch (error) {
+			currentError = (
+				error instanceof Error ? error : new Error(String(error))
+			) as TError;
+			updateStore("error", "idle", { all: false, next: false, prev: false });
+		}
+	};
+
+	const fetchNextPage = async () => {
+		if (pages.length === 0) return;
+		const nextParam = currentOptions.getNextPageParam(
+			pages[pages.length - 1],
+			pages,
+		);
+		if (nextParam === undefined) return;
+		updateStore(result.status, "fetching", {
+			all: false,
+			next: true,
+			prev: false,
+		});
+		try {
+			const page = await fetchPage(nextParam);
+			pages = [...pages, page];
+			pageParams = [...pageParams, nextParam];
+			if (currentOptions.maxPages && pages.length > currentOptions.maxPages) {
+				const excess = pages.length - currentOptions.maxPages;
+				pages = pages.slice(excess);
+				pageParams = pageParams.slice(excess);
+			}
+			currentError = null;
+			updateStore("success", "idle", { all: false, next: false, prev: false });
+		} catch (error) {
+			currentError = (
+				error instanceof Error ? error : new Error(String(error))
+			) as TError;
+			updateStore("error", "idle", { all: false, next: false, prev: false });
+		}
+	};
+
+	const fetchPreviousPage = async () => {
+		if (pages.length === 0) return;
+		if (!currentOptions.getPreviousPageParam) return;
+		const prevParam = currentOptions.getPreviousPageParam(pages[0], pages);
+		if (prevParam === undefined) return;
+		updateStore(result.status, "fetching", {
+			all: false,
+			next: false,
+			prev: true,
+		});
+		try {
+			const page = await fetchPage(prevParam);
+			pages = [page, ...pages];
+			pageParams = [prevParam, ...pageParams];
+			if (currentOptions.maxPages && pages.length > currentOptions.maxPages) {
+				pages = pages.slice(0, currentOptions.maxPages);
+				pageParams = pageParams.slice(0, currentOptions.maxPages);
+			}
+			currentError = null;
+			updateStore("success", "idle", { all: false, next: false, prev: false });
+		} catch (error) {
+			currentError = (
+				error instanceof Error ? error : new Error(String(error))
+			) as TError;
+			updateStore("error", "idle", { all: false, next: false, prev: false });
+		}
+	};
+
+	void initialize();
+
+	createEffect((prev?: InfiniteQueryOptions<TData, TError, TSelected>) => {
+		const raw = optionsAccessor();
+		const next = mergeInfiniteOptions(client, raw);
+		if (prev && hashKey(prev.queryKey) !== hashKey(next.queryKey)) {
+			currentOptions = next;
+			pages = [];
+			pageParams = [];
+			currentError = null;
+			setResult(createEmptyInfiniteResult() as unknown as typeof result);
+			void initialize();
+		} else {
+			currentOptions = next;
+		}
+		return next;
+	});
+
+	onCleanup(() => {
+		pages = [];
+		pageParams = [];
+	});
+
+	return result;
+}

package/src/query/adapters/solid/solid-query-use-mutation.ts

@@ -0,0 +1,54 @@
+import type { Accessor } from "solid-js";
+import { createEffect, onCleanup, untrack } from "solid-js";
+import { createStore } from "solid-js/store";
+import type {
+	MutationOptions,
+	MutationResult,
+} from "#query/modules/query/types";
+import { useQueryClient } from "./solid-query-context";
+import { mergeMutationOptions } from "./solid-query-options";
+
+export function useMutation<
+	TData = unknown,
+	TError = Error,
+	TVariables = void,
+	TContext = unknown,
+>(
+	optionsAccessor: Accessor<
+		MutationOptions<TData, TError, TVariables, TContext>
+	>,
+): MutationResult<TData, TError, TVariables> {
+	const client = useQueryClient();
+	const options = mergeMutationOptions(client, untrack(optionsAccessor));
+	const mutation = client.getMutationCache().build(options);
+
+	const asResult = (
+		m: typeof mutation,
+	): MutationResult<TData, TError, TVariables> =>
+		({
+			...m.getState(),
+			mutate: (variables) => {
+				void m.mutate(variables);
+			},
+			mutateAsync: (variables) => m.mutate(variables),
+			reset: () => m.reset(),
+		}) as MutationResult<TData, TError, TVariables>;
+
+	const [result, setResult] = createStore<
+		MutationResult<TData, TError, TVariables>
+	>(asResult(mutation));
+
+	const update = () => {
+		setResult(asResult(mutation) as typeof result);
+	};
+
+	mutation.subscribe(update);
+
+	createEffect(() => {
+		mutation.setOptions(mergeMutationOptions(client, optionsAccessor()));
+	});
+
+	onCleanup(() => mutation.destroy());
+
+	return result;
+}