@wrikka/solid-framework 0.0.0-stage → 0.15.0

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

@@ -0,0 +1,251 @@
+import { MutationCache } from "#query/modules/query/domain/models/mutation-cache";
+import { QueryCache } from "#query/modules/query/domain/models/query-cache";
+import { hashKey } from "#query/modules/query/domain/operations";
+import type {
+	InfiniteData,
+	InfiniteQueryOptions,
+	MutationFilter,
+	MutationOptions,
+	QueryClientConfig,
+	QueryClock,
+	QueryFilter,
+	QueryKey,
+	QueryOptions,
+	Updater,
+} from "#query/modules/query/types";
+import { getQueriesData, setQueriesData } from "./query-client-data";
+import {
+	mergeMutationOptions,
+	mergeQueryOptions,
+	persistQuery,
+	validateData,
+} from "./query-client-helpers";
+import { fetchInfiniteQuery } from "./query-client-infinite";
+
+export class QueryClient {
+	queryCache: QueryCache;
+	mutationCache: MutationCache;
+	defaultOptions: NonNullable<QueryClientConfig["defaultOptions"]>;
+	ports: NonNullable<QueryClientConfig["ports"]>;
+	clock: QueryClock;
+
+	constructor(config?: QueryClientConfig) {
+		this.ports = config?.ports ?? {};
+		this.defaultOptions = config?.defaultOptions ?? {};
+		this.clock = config?.clock ?? Date.now;
+		this.queryCache =
+			config?.queryCache ?? new QueryCache(this.ports, this.clock);
+		this.mutationCache =
+			config?.mutationCache ?? new MutationCache(this.ports, this.clock);
+	}
+
+	getQueryCache(): QueryCache {
+		return this.queryCache;
+	}
+
+	getMutationCache(): MutationCache {
+		return this.mutationCache;
+	}
+
+	getQueryData<TData>(queryKey: QueryKey): TData | undefined {
+		const query = this.queryCache.get<TData, Error>(hashKey(queryKey));
+		return query?.getState().data as TData | undefined;
+	}
+
+	setQueryData<TData>(
+		queryKey: QueryKey,
+		updater: Updater<TData | undefined, TData | undefined>,
+	): TData | undefined {
+		const hash = hashKey(queryKey);
+		let query = this.queryCache.get<TData, Error>(hash);
+
+		if (!query) {
+			const options = mergeQueryOptions<TData, Error, unknown>(
+				this.defaultOptions,
+				{
+					queryKey,
+					queryFn: async () => {
+						throw new Error("Missing queryFn");
+					},
+				} as QueryOptions<TData, Error, unknown>,
+			);
+			query = this.queryCache.build(options);
+		}
+
+		const prev = query.getState().data as TData | undefined;
+		const next =
+			typeof updater === "function"
+				? (updater as (prev: TData | undefined) => TData | undefined)(prev)
+				: updater;
+		const now = this.clock();
+		query.setState({
+			...query.getState(),
+			data: next,
+			dataUpdatedAt: now,
+			status: next === undefined ? "pending" : "success",
+		});
+		persistQuery(this.ports, query);
+		return next;
+	}
+
+	getQueriesData<TData>(filter?: QueryFilter): [QueryKey, TData | undefined][] {
+		return getQueriesData<TData>(this, filter);
+	}
+
+	setQueriesData<TData>(
+		filter: QueryFilter,
+		updater: Updater<TData | undefined, TData | undefined>,
+	): [QueryKey, TData | undefined][] {
+		return setQueriesData<TData>(this, filter, updater);
+	}
+
+	async fetchQuery<TData, TError = Error, TSelected = TData>(
+		options: QueryOptions<TData, TError, TSelected>,
+	): Promise<TData> {
+		const merged = mergeQueryOptions(this.defaultOptions, options);
+		const query = this.queryCache.build<TData, TError>(
+			merged as QueryOptions<TData, TError, unknown>,
+		);
+
+		if (this.ports.persistence && query.getState().data === undefined) {
+			const persisted = await Promise.resolve(
+				this.ports.persistence.getItem<TData>(query.queryKey),
+			);
+			if (persisted !== undefined) {
+				query.setState({
+					...query.getState(),
+					data: persisted,
+					dataUpdatedAt: this.clock(),
+					status: "success",
+				});
+			}
+		}
+
+		if (query.getState().data !== undefined && !query.isStale()) {
+			return validateData(this.ports, query.getState().data as TData);
+		}
+
+		const data = await query.fetch();
+		persistQuery(this.ports, query);
+		return validateData(this.ports, data);
+	}
+
+	prefetchQuery<TData, TError = Error, TSelected = TData>(
+		options: QueryOptions<TData, TError, TSelected>,
+	): Promise<void> {
+		return this.fetchQuery(options).then(() => undefined);
+	}
+
+	ensureQueryData<TData, TError = Error, TSelected = TData>(
+		options: QueryOptions<TData, TError, TSelected>,
+	): Promise<TData> {
+		return this.fetchQuery(options);
+	}
+
+	async fetchInfiniteQuery<TData, TError = Error, TSelected = TData>(
+		options: InfiniteQueryOptions<TData, TError, TSelected>,
+	): Promise<InfiniteData<TData>> {
+		return fetchInfiniteQuery(this, options);
+	}
+
+	async invalidateQueries(
+		filter?: QueryFilter,
+		options?: { refetchType?: "active" | "inactive" | "all" | "none" },
+	): Promise<void> {
+		const queries = this.queryCache.find(filter ?? {});
+		for (const query of queries) {
+			query.invalidate();
+		}
+
+		if (options?.refetchType === "none") return;
+
+		const refetchFilter: QueryFilter = {
+			...(filter ?? {}),
+			type: options?.refetchType ?? filter?.type ?? "active",
+		};
+		await this.refetchQueries(refetchFilter, { throwOnError: false });
+	}
+
+	async refetchQueries(
+		filter?: QueryFilter,
+		options?: { throwOnError?: boolean },
+	): Promise<unknown[]> {
+		const matchType = filter?.type ?? "all";
+		const queries = this.queryCache.find(filter ?? {}).filter((query) => {
+			const active = query.getObserversCount() > 0;
+			if (matchType === "active") return active;
+			if (matchType === "inactive") return !active;
+			return true;
+		});
+		const promises = queries.map((query) =>
+			query.refetch().catch((error) => {
+				if (options?.throwOnError) throw error;
+				return undefined;
+			}),
+		);
+		return Promise.all(promises);
+	}
+
+	async cancelQueries(filter?: QueryFilter): Promise<void> {
+		for (const query of this.queryCache.find(filter ?? {})) {
+			query.cancel();
+		}
+	}
+
+	removeQueries(filter?: QueryFilter): void {
+		for (const query of this.queryCache.find(filter ?? {})) {
+			query.destroy();
+		}
+	}
+
+	resetQueries(filter?: QueryFilter): void {
+		for (const query of this.queryCache.find(filter ?? {})) {
+			const data = query.getOptions().initialData;
+			const now = this.clock();
+			query.setState({
+				...query.getState(),
+				data,
+				dataUpdatedAt: data === undefined ? 0 : now,
+				error: null,
+				errorUpdatedAt: 0,
+				failureCount: 0,
+				failureReason: null,
+				fetchStatus: "idle",
+				status: data === undefined ? "pending" : "success",
+			});
+		}
+	}
+
+	isFetching(filter?: QueryFilter): number {
+		return this.queryCache
+			.find(filter ?? {})
+			.filter((q) => q.getState().fetchStatus === "fetching").length;
+	}
+
+	isMutating(filter?: MutationFilter): number {
+		return this.mutationCache
+			.find(filter ?? {})
+			.filter((m) => m.getState().status === "pending").length;
+	}
+
+	clear(): void {
+		this.queryCache.clear();
+		this.mutationCache.clear();
+	}
+
+	mutate<TData, TError, TVariables, TContext>(
+		options: MutationOptions<TData, TError, TVariables, TContext>,
+		variables: TVariables,
+	): Promise<TData> {
+		const merged = mergeMutationOptions(this.defaultOptions, options);
+		const mutation = this.mutationCache.build(merged);
+		return mutation.mutate(variables);
+	}
+
+	fetchMutation<TData, TError, TVariables, TContext>(
+		options: MutationOptions<TData, TError, TVariables, TContext>,
+		variables: TVariables,
+	): Promise<TData> {
+		return this.mutate(options, variables);
+	}
+}

package/src/query/modules/query/domain/models/mutation-cache.ts

@@ -0,0 +1,115 @@
+import { hashKey } from "#query/modules/query/domain/operations";
+import type { QueryClientPorts } from "#query/modules/query/ports";
+import type {
+	MutationFilter,
+	MutationOptions,
+	QueryClock,
+} from "#query/modules/query/types";
+import { Mutation } from "./mutation";
+
+export class MutationCache {
+	private cache = new Map<
+		string,
+		Mutation<unknown, unknown, unknown, unknown>
+	>();
+	private listeners = new Set<() => void>();
+	private ports?: QueryClientPorts;
+	private clock: QueryClock;
+
+	constructor(ports?: QueryClientPorts, clock: QueryClock = Date.now) {
+		this.ports = ports;
+		this.clock = clock;
+	}
+
+	get<TData, TError, TVariables, TContext>(
+		mutationHash: string,
+	): Mutation<TData, TError, TVariables, TContext> | undefined {
+		return this.cache.get(mutationHash) as
+			| Mutation<TData, TError, TVariables, TContext>
+			| undefined;
+	}
+
+	getAll(): Mutation<unknown, unknown, unknown, unknown>[] {
+		return Array.from(this.cache.values());
+	}
+
+	add(mutation: Mutation<unknown, unknown, unknown, unknown>): void {
+		const hash = mutation.mutationHash ?? this.clock().toString();
+		if (!this.cache.has(hash)) {
+			this.cache.set(hash, mutation);
+			this.ports?.devtools?.onMutationAdded?.(mutation);
+			this.notify();
+		}
+	}
+
+	remove(mutation: Mutation<unknown, unknown, unknown, unknown>): void {
+		if (mutation.mutationHash && this.cache.delete(mutation.mutationHash)) {
+			this.ports?.devtools?.onMutationRemoved?.(mutation);
+			this.notify();
+		}
+	}
+
+	clear(): void {
+		for (const mutation of this.cache.values()) {
+			mutation.cancel();
+		}
+		this.cache.clear();
+		this.notify();
+	}
+
+	subscribe(listener: () => void): () => void {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+
+	notify(): void {
+		for (const listener of this.listeners) {
+			listener();
+		}
+	}
+
+	build<TData, TError, TVariables, TContext>(
+		options: MutationOptions<TData, TError, TVariables, TContext>,
+	): Mutation<TData, TError, TVariables, TContext> {
+		const mutation = new Mutation(options, this.clock);
+		this.add(mutation as Mutation<unknown, unknown, unknown, unknown>);
+		return mutation;
+	}
+
+	find(
+		filter: MutationFilter = {},
+	): Mutation<unknown, unknown, unknown, unknown>[] {
+		return this.getAll().filter((mutation) => this.match(mutation, filter));
+	}
+
+	private match(
+		mutation: Mutation<unknown, unknown, unknown, unknown>,
+		filter: MutationFilter,
+	): boolean {
+		if (filter.predicate && !filter.predicate(mutation.mutationKey ?? []))
+			return false;
+
+		if (filter.mutationKey) {
+			if (filter.exact) {
+				if (
+					mutation.mutationKey === undefined ||
+					hashKey(mutation.mutationKey) !== hashKey(filter.mutationKey)
+				)
+					return false;
+			} else {
+				if (mutation.mutationKey === undefined) return false;
+				const a = mutation.mutationKey;
+				const b = filter.mutationKey;
+				if (b.length > a.length) return false;
+				if (!a.slice(0, b.length).every((value, index) => value === b[index]))
+					return false;
+			}
+		}
+
+		if (filter.status) {
+			if (mutation.getState().status !== filter.status) return false;
+		}
+
+		return true;
+	}
+}

package/src/query/modules/query/domain/models/mutation.ts

@@ -0,0 +1,207 @@
+import {
+	calculateRetryDelay,
+	hashKey,
+	shouldRetry,
+} from "#query/modules/query/domain/operations";
+import type {
+	MutationOptions,
+	MutationState,
+	MutationStatus,
+	QueryClock,
+	QueryKey,
+} from "#query/modules/query/types";
+
+const createInitialState = <TData, TError, TVariables>(): MutationState<
+	TData,
+	TError,
+	TVariables
+> => ({
+	data: undefined,
+	error: null,
+	failureCount: 0,
+	failureReason: null,
+	isIdle: true,
+	isPending: false,
+	isPaused: false,
+	isSuccess: false,
+	isError: false,
+	status: "idle",
+	submittedAt: 0,
+	variables: undefined,
+});
+
+export class Mutation<
+	TData = unknown,
+	TError = Error,
+	TVariables = void,
+	TContext = unknown,
+> {
+	readonly mutationKey?: QueryKey;
+	readonly mutationHash?: string;
+	private options: MutationOptions<TData, TError, TVariables, TContext>;
+	private state: MutationState<TData, TError, TVariables>;
+	private listeners = new Set<() => void>();
+	private abortController: AbortController | null = null;
+	private clock: QueryClock;
+
+	constructor(
+		options: MutationOptions<TData, TError, TVariables, TContext>,
+		clock: QueryClock,
+	) {
+		this.options = options;
+		this.mutationKey = options.mutationKey;
+		this.mutationHash = options.mutationKey
+			? hashKey(options.mutationKey)
+			: undefined;
+		this.state = createInitialState<TData, TError, TVariables>();
+		this.clock = clock;
+	}
+
+	getState(): MutationState<TData, TError, TVariables> {
+		return this.state;
+	}
+
+	setState(
+		updater:
+			| MutationState<TData, TError, TVariables>
+			| ((
+					prev: MutationState<TData, TError, TVariables>,
+			  ) => MutationState<TData, TError, TVariables>),
+	): void {
+		const nextState =
+			typeof updater === "function" ? updater(this.state) : updater;
+		this.state = nextState;
+		this.notify();
+	}
+
+	setOptions(
+		options: Partial<MutationOptions<TData, TError, TVariables, TContext>>,
+	): void {
+		this.options = { ...this.options, ...options };
+	}
+
+	subscribe(listener: () => void): () => void {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+
+	async mutate(variables: TVariables): Promise<TData> {
+		return this.execute(variables);
+	}
+
+	reset(): void {
+		this.setState(createInitialState<TData, TError, TVariables>());
+	}
+
+	cancel(): void {
+		if (this.abortController) {
+			this.abortController.abort();
+			this.abortController = null;
+		}
+	}
+
+	destroy(): void {
+		this.cancel();
+		this.listeners.clear();
+	}
+
+	private notify(): void {
+		for (const listener of this.listeners) {
+			listener();
+		}
+	}
+
+	private async execute(variables: TVariables): Promise<TData> {
+		const { mutationFn, onMutate, onSuccess, onError, onSettled } =
+			this.options;
+		const now = this.clock();
+
+		this.setState({
+			...createInitialState<TData, TError, TVariables>(),
+			isIdle: false,
+			isPending: true,
+			status: "pending" as MutationStatus,
+			submittedAt: now,
+			variables,
+		});
+
+		let context: TContext | undefined;
+		try {
+			context = await onMutate?.(variables);
+		} catch {
+			context = undefined;
+		}
+
+		const controller = new AbortController();
+		this.abortController = controller;
+
+		let failureCount = 0;
+
+		while (true) {
+			try {
+				const data = await mutationFn(variables);
+				if (controller.signal.aborted) {
+					throw new Error(String(controller.signal.reason));
+				}
+
+				this.setState({
+					...this.state,
+					data,
+					error: null,
+					failureCount: 0,
+					failureReason: null,
+					isPending: false,
+					isSuccess: true,
+					isError: false,
+					status: "success",
+					variables,
+				});
+
+				await onSuccess?.(data, variables, context);
+				await onSettled?.(data, null, variables, context);
+				this.abortController = null;
+				return data;
+			} catch (rawError) {
+				if (controller.signal.aborted) {
+					this.setState((prev) => ({
+						...prev,
+						isPending: false,
+						isIdle: true,
+						status: "idle" as MutationStatus,
+					}));
+					this.abortController = null;
+					throw rawError;
+				}
+
+				const error = rawError as TError;
+				failureCount += 1;
+
+				this.setState((prev) => ({
+					...prev,
+					error,
+					failureCount,
+					failureReason: error,
+					isPending: false,
+					isError: true,
+					isSuccess: false,
+					status: "error" as MutationStatus,
+					variables,
+				}));
+
+				if (!shouldRetry(failureCount, error, this.options.retry ?? false)) {
+					this.abortController = null;
+					await onError?.(error, variables, context);
+					await onSettled?.(undefined, error, variables, context);
+					throw error;
+				}
+
+				const delay = calculateRetryDelay(
+					failureCount,
+					error,
+					this.options.retryDelay ?? 1000,
+				);
+				await new Promise((resolve) => setTimeout(resolve, delay));
+			}
+		}
+	}
+}

package/src/query/modules/query/domain/models/query-cache.ts

@@ -0,0 +1,119 @@
+import {
+	hashKey,
+	isQueryKeyEqual,
+	isQueryKeyPrefix,
+} from "#query/modules/query/domain/operations";
+import type { QueryClientPorts } from "#query/modules/query/ports";
+import type {
+	QueryClock,
+	QueryFilter,
+	QueryOptions,
+} from "#query/modules/query/types";
+import { Query } from "./query";
+
+export class QueryCache {
+	private cache = new Map<string, Query<unknown, unknown>>();
+	private listeners = new Set<() => void>();
+	private ports?: QueryClientPorts;
+	private clock: QueryClock;
+
+	constructor(ports?: QueryClientPorts, clock: QueryClock = Date.now) {
+		this.ports = ports;
+		this.clock = clock;
+	}
+
+	get<TData, TError = Error>(
+		queryHash: string,
+	): Query<TData, TError> | undefined {
+		return this.cache.get(queryHash) as Query<TData, TError> | undefined;
+	}
+
+	getAll(): Query<unknown, unknown>[] {
+		return Array.from(this.cache.values());
+	}
+
+	getAllInOrder(): Query<unknown, unknown>[] {
+		return this.getAll();
+	}
+
+	add(query: Query<unknown, unknown>): void {
+		if (!this.cache.has(query.queryHash)) {
+			this.cache.set(query.queryHash, query);
+			this.ports?.devtools?.onQueryAdded?.(query);
+			this.notify();
+		}
+	}
+
+	remove(query: Query<unknown, unknown>): void {
+		if (this.cache.delete(query.queryHash)) {
+			this.ports?.devtools?.onQueryRemoved?.(query);
+			this.notify();
+		}
+	}
+
+	removeByHash(queryHash: string): void {
+		const query = this.cache.get(queryHash);
+		if (query) {
+			this.remove(query);
+		}
+	}
+
+	clear(): void {
+		for (const query of this.cache.values()) {
+			query.cancel();
+		}
+		this.cache.clear();
+		this.notify();
+	}
+
+	subscribe(listener: () => void): () => void {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+
+	notify(): void {
+		for (const listener of this.listeners) listener();
+	}
+
+	build<TData, TError = Error>(
+		options: QueryOptions<TData, TError, unknown>,
+	): Query<TData, TError> {
+		const queryHash = hashKey(options.queryKey);
+		const existing = this.cache.get(queryHash);
+		if (existing) {
+			existing.setOptions(options as QueryOptions<unknown, unknown, unknown>);
+			return existing as Query<TData, TError>;
+		}
+		const query = new Query(options, this, this.clock);
+		this.add(query as Query<unknown, unknown>);
+		return query as Query<TData, TError>;
+	}
+
+	find(filter: QueryFilter = {}): Query<unknown, unknown>[] {
+		return this.getAll().filter((query) => this.match(query, filter));
+	}
+
+	private match(query: Query<unknown, unknown>, filter: QueryFilter): boolean {
+		if (filter.predicate && !filter.predicate(query.queryKey)) return false;
+
+		if (filter.queryKey) {
+			if (filter.exact) {
+				if (!isQueryKeyEqual(query.queryKey, filter.queryKey)) return false;
+			} else {
+				if (!isQueryKeyPrefix(query.queryKey, filter.queryKey)) return false;
+			}
+		}
+
+		if (filter.type) {
+			const active = query.getObserversCount() > 0;
+			if (filter.type === "active" && !active) return false;
+			if (filter.type === "inactive" && active) return false;
+		}
+
+		if (filter.stale !== undefined) {
+			if (query.isStale() !== filter.stale) return false;
+		}
+
+		return true;
+	}
+}

package/src/query/modules/query/domain/models/query-environment.ts

@@ -0,0 +1,16 @@
+export const isOnlineForMode = (
+	networkMode?: "online" | "always" | "offlineFirst",
+): boolean => {
+	if (networkMode === "always") return true;
+	if (networkMode === "offlineFirst") return true;
+	return typeof navigator !== "undefined" ? navigator.onLine !== false : true;
+};
+
+export const documentIsVisibleForMode = (
+	refetchIntervalInBackground?: boolean,
+): boolean => {
+	if (refetchIntervalInBackground) return true;
+	return typeof document !== "undefined"
+		? document.visibilityState !== "hidden"
+		: true;
+};