@wrikka/solid-framework 0.0.0-stage → 0.15.0

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

@@ -0,0 +1,75 @@
+import type { Accessor } from "solid-js";
+import { createEffect, onCleanup, untrack } from "solid-js";
+import { createStore } from "solid-js/store";
+import { QueryObserver } from "#query/modules/query/domain/models/query-observer";
+import { hashKey } from "#query/modules/query/domain/operations";
+import type {
+	QueryObserverResult,
+	QueryOptions,
+} from "#query/modules/query/types";
+import { useQueryClient } from "./solid-query-context";
+import { resolveQueryOptions } from "./solid-query-options";
+
+export function useQuery<TData = unknown, TError = Error, TSelected = TData>(
+	optionsAccessor: Accessor<QueryOptions<TData, TError, TSelected>>,
+): QueryObserverResult<TSelected, TError> & { refetch: () => Promise<TData> } {
+	const client = useQueryClient();
+	const initialOptions = resolveQueryOptions(client, untrack(optionsAccessor));
+	const initialQuery = client
+		.getQueryCache()
+		.build(initialOptions as QueryOptions<TData, TError, unknown>);
+
+	let observer = new QueryObserver<TData, TError, TSelected>(
+		initialQuery,
+		initialOptions,
+	);
+
+	const [result, setResult] = createStore<
+		QueryObserverResult<TSelected, TError> & { refetch: () => Promise<TData> }
+	>({
+		...observer.getCurrentResult(),
+		refetch: () => observer.refetch(),
+	});
+
+	const updateResult = (
+		r: QueryObserverResult<TSelected, TError>,
+		o: QueryObserver<TData, TError, TSelected>,
+	) => {
+		setResult({
+			...r,
+			refetch: () => o.refetch(),
+		} as typeof result);
+	};
+
+	observer.subscribe((r) => updateResult(r, observer));
+
+	if (observer.willFetch()) {
+		void observer.fetch();
+	}
+
+	onCleanup(() => observer.destroy());
+
+	createEffect((prev?: QueryOptions<TData, TError, TSelected>) => {
+		const raw = optionsAccessor();
+		const nextOptions = resolveQueryOptions(client, raw);
+		if (prev && hashKey(prev.queryKey) !== hashKey(nextOptions.queryKey)) {
+			observer.destroy();
+			const nextQuery = client
+				.getQueryCache()
+				.build(nextOptions as QueryOptions<TData, TError, unknown>);
+			observer = new QueryObserver<TData, TError, TSelected>(
+				nextQuery,
+				nextOptions,
+			);
+			updateResult(observer.getCurrentResult(), observer);
+			observer.subscribe((r) => updateResult(r, observer));
+			if (observer.willFetch()) void observer.fetch();
+			onCleanup(() => observer.destroy());
+		} else {
+			observer.setOptions(nextOptions);
+		}
+		return nextOptions;
+	});
+
+	return result;
+}

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

@@ -0,0 +1,53 @@
+import { createRoot } from "solid-js";
+import { describe, expect, it } from "vitest";
+import type { QueryOptions } from "#query/modules/query";
+import { QueryClient } from "#query/modules/query";
+import { createQuery, QueryClientProvider, useQueryClient } from "./index";
+
+describe("Solid adapter", () => {
+	it("provides a QueryClient via context", () => {
+		const client = new QueryClient();
+		let resolved: QueryClient | undefined;
+		createRoot((dispose) => {
+			QueryClientProvider({
+				client,
+				get children() {
+					resolved = useQueryClient();
+					return null;
+				},
+			});
+			dispose();
+		});
+		expect(resolved).toBe(client);
+	});
+
+	it("creates a query result", async () => {
+		const client = new QueryClient();
+		const options = (): QueryOptions<string> => ({
+			queryKey: ["hello"],
+			queryFn: async () => "world",
+		});
+
+		await new Promise<void>((resolve) => {
+			createRoot((dispose) => {
+				QueryClientProvider({
+					client,
+					get children() {
+						const result = createQuery(options);
+						const check = () => {
+							if (result.isSuccess) {
+								expect(result.data).toBe("world");
+								dispose();
+								resolve();
+							} else {
+								setTimeout(check, 5);
+							}
+						};
+						check();
+						return null;
+					},
+				});
+			});
+		});
+	});
+});

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

@@ -0,0 +1,20 @@
+import type { Type } from "arktype";
+import type {
+	QueryValidationPort,
+	QueryValidationResult,
+} from "#query/modules/query/ports";
+
+export type { QueryValidationPort };
+
+export const createArktypeValidation = <T>(
+	schema: Type<T>,
+): QueryValidationPort<T> => ({
+	name: "arktype",
+	validate: (data: unknown): QueryValidationResult<T> => {
+		const result = schema(data);
+		if (result instanceof TypeError) {
+			return { success: false, errors: [result.message] };
+		}
+		return { success: true, data: result as T };
+	},
+});

package/src/query/index.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, it, vi } from "vitest";
+import { QueryClient } from "#query/modules/query/application/usecases/query-client";
+
+describe("QueryClient", () => {
+	it("should fetch and cache a query", async () => {
+		const client = new QueryClient();
+		const data = await client.fetchQuery({
+			queryKey: ["todos"],
+			queryFn: async () => [{ id: 1, title: "Todo 1" }],
+		});
+		expect(data).toEqual([{ id: 1, title: "Todo 1" }]);
+		expect(client.getQueryData(["todos"])).toEqual(data);
+	});
+
+	it("should return cached data when not stale", async () => {
+		const client = new QueryClient();
+		const queryFn = vi.fn().mockResolvedValueOnce([{ id: 1 }]);
+		await client.fetchQuery({
+			queryKey: ["todos"],
+			queryFn,
+			staleTime: 10000,
+		});
+		const data = await client.fetchQuery({
+			queryKey: ["todos"],
+			queryFn,
+			staleTime: 10000,
+		});
+		expect(data).toEqual([{ id: 1 }]);
+		expect(queryFn).toHaveBeenCalledTimes(1);
+	});
+
+	it("should refetch stale data", async () => {
+		const client = new QueryClient();
+		const queryFn = vi
+			.fn()
+			.mockResolvedValueOnce([{ id: 1 }])
+			.mockResolvedValueOnce([{ id: 1 }, { id: 2 }]);
+		await client.fetchQuery({
+			queryKey: ["todos"],
+			queryFn,
+			staleTime: 0,
+		});
+		await client.refetchQueries({ queryKey: ["todos"] });
+		expect(queryFn).toHaveBeenCalledTimes(2);
+		expect(client.getQueryData(["todos"])).toEqual([{ id: 1 }, { id: 2 }]);
+	});
+
+	it("should invalidate and refetch", async () => {
+		const client = new QueryClient();
+		const queryFn = vi
+			.fn()
+			.mockResolvedValueOnce([{ id: 1 }])
+			.mockResolvedValueOnce([{ id: 2 }]);
+		await client.fetchQuery({
+			queryKey: ["todos"],
+			queryFn,
+			staleTime: 10000,
+		});
+		await client.invalidateQueries(
+			{ queryKey: ["todos"] },
+			{ refetchType: "all" },
+		);
+		expect(queryFn).toHaveBeenCalledTimes(2);
+	});
+
+	it("should cancel a query", async () => {
+		const client = new QueryClient();
+		let aborted = false;
+		const fetchPromise = client.fetchQuery({
+			queryKey: ["slow"],
+			queryFn: async ({ signal }) => {
+				return new Promise<number>((resolve, reject) => {
+					signal.addEventListener("abort", () => {
+						aborted = true;
+						reject(new Error("aborted"));
+					});
+					setTimeout(() => resolve(42), 1000);
+				});
+			},
+		});
+		client.cancelQueries({ queryKey: ["slow"] });
+		await expect(fetchPromise).rejects.toThrow("aborted");
+		expect(aborted).toBe(true);
+	});
+
+	it("should retry a failed query", async () => {
+		const client = new QueryClient();
+		const queryFn = vi
+			.fn()
+			.mockRejectedValueOnce(new Error("fail"))
+			.mockResolvedValueOnce([{ id: 1 }]);
+		const data = await client.fetchQuery({
+			queryKey: ["retry"],
+			queryFn,
+			retry: 1,
+			retryDelay: 10,
+		});
+		expect(data).toEqual([{ id: 1 }]);
+		expect(queryFn).toHaveBeenCalledTimes(2);
+	});
+
+	it("should set query data manually", async () => {
+		const client = new QueryClient();
+		client.setQueryData(["todos"], [{ id: 1 }]);
+		expect(client.getQueryData(["todos"])).toEqual([{ id: 1 }]);
+	});
+
+	it("should remove queries", async () => {
+		const client = new QueryClient();
+		await client.fetchQuery({
+			queryKey: ["todos"],
+			queryFn: async () => [{ id: 1 }],
+		});
+		client.removeQueries({ queryKey: ["todos"] });
+		expect(client.getQueryData(["todos"])).toBeUndefined();
+	});
+
+	it("should clear client", async () => {
+		const client = new QueryClient();
+		await client.fetchQuery({
+			queryKey: ["todos"],
+			queryFn: async () => [{ id: 1 }],
+		});
+		client.clear();
+		expect(client.getQueryData(["todos"])).toBeUndefined();
+	});
+
+	it("should track isFetching", async () => {
+		const client = new QueryClient();
+		let resolve: (value: unknown) => void = () => {};
+		const promise = new Promise((res) => {
+			resolve = res;
+		});
+		client.fetchQuery({
+			queryKey: ["pending"],
+			queryFn: async () => {
+				await promise;
+				return "done";
+			},
+		});
+		expect(client.isFetching({ queryKey: ["pending"] })).toBe(1);
+		resolve("done");
+		await new Promise((res) => setTimeout(res, 10));
+		expect(client.isFetching({ queryKey: ["pending"] })).toBe(0);
+	});
+});
+
+describe("Mutation", () => {
+	it("should execute a mutation", async () => {
+		const client = new QueryClient();
+		const result = await client.fetchMutation(
+			{
+				mutationFn: async (variables: { name: string }) => ({
+					id: 1,
+					name: variables.name,
+				}),
+			},
+			{ name: "New" },
+		);
+		expect(result).toEqual({ id: 1, name: "New" });
+	});
+
+	it("should call lifecycle callbacks", async () => {
+		const client = new QueryClient();
+		const onSuccess = vi.fn();
+		const onSettled = vi.fn();
+		await client.fetchMutation(
+			{
+				mutationFn: async (variables: { name: string }) => ({
+					id: 1,
+					name: variables.name,
+				}),
+				onSuccess,
+				onSettled,
+			},
+			{ name: "New" },
+		);
+		expect(onSuccess).toHaveBeenCalledWith(
+			{ id: 1, name: "New" },
+			{ name: "New" },
+			undefined,
+		);
+		expect(onSettled).toHaveBeenCalled();
+	});
+
+	it("should retry a failed mutation", async () => {
+		const client = new QueryClient();
+		const mutationFn = vi
+			.fn()
+			.mockRejectedValueOnce(new Error("fail"))
+			.mockResolvedValueOnce({ id: 1 });
+		const result = await client.fetchMutation(
+			{
+				mutationFn,
+				retry: 1,
+				retryDelay: 10,
+			},
+			undefined,
+		);
+		expect(result).toEqual({ id: 1 });
+		expect(mutationFn).toHaveBeenCalledTimes(2);
+	});
+});

package/src/query/index.ts

@@ -0,0 +1,4 @@
+export * from "#query/adapters/devtools";
+export * from "#query/adapters/persistence";
+export * from "#query/adapters/validation";
+export * from "#query/modules/query";

package/src/query/modules/query/application/usecases/query-client-data.ts

@@ -0,0 +1,29 @@
+import type {
+	QueryFilter,
+	QueryKey,
+	Updater,
+} from "#query/modules/query/types";
+import type { QueryClient } from "./query-client";
+
+export const getQueriesData = <TData>(
+	client: QueryClient,
+	filter?: QueryFilter,
+): [QueryKey, TData | undefined][] =>
+	client.queryCache
+		.find(filter ?? {})
+		.map((query) => [
+			query.queryKey,
+			query.getState().data as TData | undefined,
+		]);
+
+export const setQueriesData = <TData>(
+	client: QueryClient,
+	filter: QueryFilter,
+	updater: Updater<TData | undefined, TData | undefined>,
+): [QueryKey, TData | undefined][] =>
+	client.queryCache
+		.find(filter)
+		.map((query) => [
+			query.queryKey,
+			client.setQueryData(query.queryKey, updater),
+		]);

package/src/query/modules/query/application/usecases/query-client-helpers.ts

@@ -0,0 +1,49 @@
+import type { Query } from "#query/modules/query/domain/models/query";
+import type {
+	MutationOptions,
+	QueryClientConfig,
+	QueryOptions,
+} from "#query/modules/query/types";
+
+export const mergeQueryOptions = <TData, TError, TSelected>(
+	defaultOptions: NonNullable<QueryClientConfig["defaultOptions"]>,
+	options: QueryOptions<TData, TError, TSelected>,
+): QueryOptions<TData, TError, TSelected> => {
+	const base = defaultOptions.queries ?? {};
+	return {
+		...base,
+		...options,
+	} as QueryOptions<TData, TError, TSelected>;
+};
+
+export const mergeMutationOptions = <TData, TError, TVariables, TContext>(
+	defaultOptions: NonNullable<QueryClientConfig["defaultOptions"]>,
+	options: MutationOptions<TData, TError, TVariables, TContext>,
+): MutationOptions<TData, TError, TVariables, TContext> => {
+	const base = defaultOptions.mutations ?? {};
+	return {
+		...base,
+		...options,
+	} as MutationOptions<TData, TError, TVariables, TContext>;
+};
+
+export const persistQuery = <TData, TError = Error>(
+	ports: NonNullable<QueryClientConfig["ports"]>,
+	query: Query<TData, TError>,
+): void => {
+	if (ports.persistence && query.getState().data !== undefined) {
+		void Promise.resolve(
+			ports.persistence.setItem(query.queryKey, query.getState().data),
+		);
+	}
+};
+
+export const validateData = <TData>(
+	ports: NonNullable<QueryClientConfig["ports"]>,
+	data: TData,
+): TData => {
+	if (!ports.validation) return data;
+	const result = ports.validation.validate(data);
+	if (result.success) return result.data as TData;
+	throw new Error(result.errors?.join(", ") ?? "validation failed");
+};

package/src/query/modules/query/application/usecases/query-client-infinite.ts

@@ -0,0 +1,39 @@
+import type {
+	InfiniteData,
+	InfiniteQueryOptions,
+	QueryOptions,
+} from "#query/modules/query/types";
+import type { QueryClient } from "./query-client";
+
+export const fetchInfiniteQuery = async <
+	TData,
+	TError = Error,
+	TSelected = TData,
+>(
+	client: QueryClient,
+	options: InfiniteQueryOptions<TData, TError, TSelected>,
+): Promise<InfiniteData<TData>> => {
+	const result: InfiniteData<TData> = { pages: [], pageParams: [] };
+	let nextParam: unknown | undefined = options.initialPageParam;
+
+	while (
+		nextParam !== undefined &&
+		(!options.maxPages || result.pages.length < options.maxPages)
+	) {
+		const page = await client.fetchQuery<TData, TError, TData>({
+			queryKey: [...options.queryKey, nextParam],
+			queryFn: (ctx) => options.queryFn({ ...ctx, pageParam: nextParam }),
+			staleTime: options.staleTime,
+			gcTime: options.gcTime,
+			retry: options.retry,
+			retryDelay: options.retryDelay,
+			networkMode: options.networkMode,
+			meta: options.meta,
+		} as QueryOptions<TData, TError, TData>);
+		result.pages.push(page);
+		result.pageParams.push(nextParam);
+		nextParam = options.getNextPageParam(page, result.pages);
+	}
+
+	return result;
+};