@raf-query/core 0.0.3 → 0.0.4

package/dist/query.mjs

@@ -0,0 +1,394 @@
+import { scheduleNotify } from "./notify.mjs";
+import { fulfilled, pending } from "./thenable.mjs";
+import { Cause, Effect, Exit, Predicate, Schedule } from "effect";
+//#region src/query.ts
+/** Thrown into a request's awaiters when the cache is cleared mid-request. */
+var CancelledError = class extends Error {
+	constructor() {
+		super("The query was cancelled");
+		this.name = "CancelledError";
+	}
+};
+const noop = () => {};
+const identity = (value) => value;
+const defaultObserver = {};
+function isEffectResult(result) {
+	return Effect.isEffect(result);
+}
+function isInfiniteData(data) {
+	return Predicate.hasProperty(data, "pages") && Predicate.hasProperty(data, "pageParams") && Array.isArray(data.pages) && Array.isArray(data.pageParams);
+}
+function shouldRetry(retry, failureCount, error) {
+	if (Predicate.isBoolean(retry)) return retry;
+	if (Predicate.isNumber(retry)) return failureCount <= retry;
+	return retry(failureCount, error);
+}
+function nextPageParam(options, data) {
+	if (data.pages.length === 0) return;
+	return options.getNextPageParam(data.pages.at(-1), data.pages, data.pageParams.at(-1), data.pageParams);
+}
+function previousPageParam(options, data) {
+	if (data.pages.length === 0 || !options.getPreviousPageParam) return;
+	return options.getPreviousPageParam(data.pages[0], data.pages, data.pageParams[0], data.pageParams);
+}
+function addPage(data, page, pageParam, direction, maxPages) {
+	const forward = direction === "forward";
+	const pages = forward ? [...data.pages, page] : [page, ...data.pages];
+	const pageParams = forward ? [...data.pageParams, pageParam] : [pageParam, ...data.pageParams];
+	if (maxPages === void 0 || pages.length <= maxPages) return {
+		pageParams,
+		pages
+	};
+	return forward ? {
+		pageParams: pageParams.slice(-maxPages),
+		pages: pages.slice(-maxPages)
+	} : {
+		pageParams: pageParams.slice(0, maxPages),
+		pages: pages.slice(0, maxPages)
+	};
+}
+var QueryEntry = class {
+	hash;
+	key;
+	#errorShown = false;
+	#errorShownTimer;
+	#gcTimer;
+	#handle;
+	#host;
+	#inFlight;
+	#listeners = /* @__PURE__ */ new Map();
+	#options;
+	#pending;
+	#staleTimer;
+	#state;
+	constructor(host, key, hash) {
+		this.#host = host;
+		this.key = key;
+		this.hash = hash;
+		this.#handle = {
+			input: void 0,
+			key
+		};
+		this.#pending = pending();
+		this.#state = {
+			data: void 0,
+			error: null,
+			failureCount: 0,
+			fetchDirection: void 0,
+			hasData: false,
+			isFetching: false,
+			isInvalidated: false,
+			isStale: true,
+			promise: this.#pending.promise,
+			status: "pending",
+			updatedAt: 0
+		};
+		this.#scheduleGc();
+	}
+	get handle() {
+		return this.#handle;
+	}
+	get options() {
+		return this.#options;
+	}
+	/** Readers are subscribed; `invalidate` and focus refetch only what is read. */
+	get isObserved() {
+		return this.#listeners.size > 0;
+	}
+	getState = () => this.#state;
+	/** Staleness as of now; `getState().isStale` is only refreshed for read entries. */
+	isStaleNow = () => this.#computeStale(this.#state);
+	subscribe = (listener, observer = defaultObserver) => {
+		this.#listeners.set(listener, observer);
+		this.#clearGc();
+		this.#scheduleStale();
+		return () => {
+			this.#listeners.delete(listener);
+			if (this.#listeners.size === 0) {
+				clearTimeout(this.#staleTimer);
+				this.#scheduleGc();
+			}
+		};
+	};
+	/** Attach the options and input of the latest factory call. */
+	setOptions(options, input) {
+		this.#options = options;
+		if (this.#handle.input !== input) this.#handle = {
+			input,
+			key: this.key
+		};
+	}
+	read = () => {
+		const state = this.#state;
+		if (!state.hasData && !state.isFetching) {
+			if (state.status !== "error" || this.#errorShown) this.fetch().catch(noop);
+			else this.#markErrorShown();
+		}
+		return this.#state.promise;
+	};
+	fetch = (request = {}) => {
+		const options = this.#options;
+		const inFlight = this.#inFlight;
+		if (inFlight && !(request.restart && options)) {
+			if (request.direction) {
+				const next = () => this.fetch(request);
+				return inFlight.deferred.promise.then(next, next);
+			}
+			return inFlight.deferred.promise;
+		}
+		if (!options) return this.#state.promise;
+		inFlight?.controller.abort();
+		return this.#start(this.#request(options, request), request.direction);
+	};
+	refetch = () => this.fetch().then(noop, noop);
+	fetchNextPage = () => this.fetch({ direction: "forward" }).then(noop, noop);
+	fetchPreviousPage = () => this.fetch({ direction: "backward" }).then(noop, noop);
+	hasNextPage = () => {
+		const options = this.#options;
+		const data = this.#state.data;
+		return options?.kind === "infinite" && isInfiniteData(data) && nextPageParam(options, data) != null;
+	};
+	hasPreviousPage = () => {
+		const options = this.#options;
+		const data = this.#state.data;
+		return options?.kind === "infinite" && isInfiniteData(data) && previousPageParam(options, data) != null;
+	};
+	invalidate = () => {
+		this.#set({ isInvalidated: true });
+		if (!this.isObserved || !this.#options) return Promise.resolve();
+		return this.fetch({ restart: true }).then(noop, noop);
+	};
+	/** Write data directly, as if a request had returned it. */
+	setData(data, updatedAt = Date.now()) {
+		this.#succeed(data, updatedAt);
+	}
+	/** Adopt a request started elsewhere (the server's, during hydration). */
+	resume(promise) {
+		if (this.#state.hasData || this.#inFlight) return;
+		this.#start(Effect.tryPromise({
+			catch: identity,
+			try: () => Promise.resolve(promise)
+		}), void 0).catch(noop);
+	}
+	/** Refetch a read, stale entry whose readers want it on this event. */
+	onWindowEvent(event) {
+		const option = event === "focus" ? "refetchOnWindowFocus" : "refetchOnReconnect";
+		const fallback = this.#behavior(option) ?? true;
+		if ([...this.#listeners.values()].some((observer) => observer[option] ?? fallback) && this.#computeStale(this.#state)) this.fetch().catch(noop);
+	}
+	/** Stop timers and abort the in-flight request; the entry is leaving the cache. */
+	destroy() {
+		clearTimeout(this.#gcTimer);
+		clearTimeout(this.#staleTimer);
+		clearTimeout(this.#errorShownTimer);
+		const inFlight = this.#inFlight;
+		this.#inFlight = void 0;
+		if (inFlight) {
+			inFlight.controller.abort();
+			inFlight.deferred.reject(new CancelledError());
+		}
+	}
+	#behavior(name) {
+		return this.#options?.[name] ?? this.#host.defaults[name];
+	}
+	#computeStale(state) {
+		if (state.isInvalidated || !state.hasData) return true;
+		const staleTime = this.#behavior("staleTime") ?? 0;
+		return Date.now() - state.updatedAt >= staleTime;
+	}
+	#set(patch) {
+		const next = {
+			...this.#state,
+			...patch
+		};
+		this.#state = {
+			...next,
+			isStale: this.#computeStale(next)
+		};
+		for (const listener of this.#listeners.keys()) scheduleNotify(listener);
+		this.#host.changed(this);
+		this.#scheduleStale();
+	}
+	#start(request, direction) {
+		const deferred = this.#inFlight?.deferred ?? pending();
+		const run = {
+			controller: new AbortController(),
+			deferred
+		};
+		this.#inFlight = run;
+		this.#clearGc();
+		if (!this.#state.hasData && this.#state.status === "error") {
+			this.#pending = pending();
+			this.#set({
+				error: null,
+				failureCount: 0,
+				fetchDirection: direction,
+				isFetching: true,
+				promise: this.#pending.promise,
+				status: "pending"
+			});
+		} else this.#set({
+			failureCount: 0,
+			fetchDirection: direction,
+			isFetching: true
+		});
+		Effect.runPromiseExit(request, { signal: run.controller.signal }).then((exit) => this.#settle(run, exit), noop);
+		return deferred.promise;
+	}
+	#settle(run, exit) {
+		if (this.#inFlight !== run) return;
+		this.#inFlight = void 0;
+		if (Exit.isSuccess(exit)) {
+			this.#succeed(exit.value, Date.now());
+			run.deferred.resolve(exit.value);
+		} else if (Cause.hasInterruptsOnly(exit.cause)) {
+			this.#set({
+				fetchDirection: void 0,
+				isFetching: false
+			});
+			run.deferred.reject(new CancelledError());
+		} else {
+			const error = Cause.squash(exit.cause);
+			this.#fail(error);
+			run.deferred.reject(error);
+		}
+		this.#scheduleGc();
+	}
+	#succeed(data, updatedAt) {
+		const firstLoad = this.#pending;
+		this.#pending = void 0;
+		firstLoad?.resolve(data);
+		this.#set({
+			data,
+			error: null,
+			failureCount: 0,
+			fetchDirection: void 0,
+			hasData: true,
+			isFetching: false,
+			isInvalidated: false,
+			promise: firstLoad ? firstLoad.promise : fulfilled(data),
+			status: "success",
+			updatedAt
+		});
+	}
+	#fail(error) {
+		this.#host.reportError(error, this);
+		if (!this.#state.hasData) {
+			const firstLoad = this.#pending;
+			this.#pending = void 0;
+			firstLoad?.reject(error);
+			this.#errorShown = false;
+		}
+		this.#set({
+			error,
+			fetchDirection: void 0,
+			isFetching: false,
+			status: "error"
+		});
+	}
+	/**
+	* A failed first load rejects its promise, so the reader throws to an error
+	* boundary. Every read in that same task (React retries a throwing render
+	* once, StrictMode renders twice) gets the rejection too; a read in a later
+	* task — the boundary was reset — starts a new request.
+	*/
+	#markErrorShown() {
+		if (this.#errorShownTimer !== void 0) return;
+		this.#errorShownTimer = setTimeout(() => {
+			this.#errorShownTimer = void 0;
+			this.#errorShown = true;
+		}, 0);
+	}
+	#request(options, request) {
+		if (options.kind === "query") return this.#attempt((signal) => options.queryFn({
+			queryKey: options.queryKey,
+			signal
+		}));
+		return this.#pagedRequest(options, request);
+	}
+	#pagedRequest(options, request) {
+		const current = isInfiniteData(this.#state.data) ? this.#state.data : void 0;
+		const fetchPage = (pageParam, direction) => this.#attempt((signal) => options.queryFn({
+			direction,
+			pageParam,
+			queryKey: options.queryKey,
+			signal
+		}));
+		return Effect.gen(function* () {
+			if (request.direction && current) {
+				const pageParam = request.direction === "forward" ? nextPageParam(options, current) : previousPageParam(options, current);
+				if (pageParam == null) return current;
+				const page = yield* fetchPage(pageParam, request.direction);
+				return addPage(current, page, pageParam, request.direction, options.maxPages);
+			}
+			const count = Math.max(request.pages ?? 1, current?.pages.length ?? 0);
+			let data = {
+				pageParams: [],
+				pages: []
+			};
+			let pageParam = current && current.pageParams.length > 0 ? current.pageParams[0] : options.initialPageParam;
+			for (let index = 0; index < count; index++) {
+				if (index > 0) {
+					const next = nextPageParam(options, data);
+					if (next == null) break;
+					pageParam = next;
+				}
+				const page = yield* fetchPage(pageParam, "forward");
+				data = addPage(data, page, pageParam, "forward", options.maxPages);
+			}
+			return data;
+		});
+	}
+	/** One request: run the `queryFn` with a fresh signal, retrying per policy. */
+	#attempt(call) {
+		const once = Effect.suspend(() => {
+			const controller = new AbortController();
+			return Effect.try({
+				catch: identity,
+				try: () => call(controller.signal)
+			}).pipe(Effect.flatMap((result) => isEffectResult(result) ? result : Effect.tryPromise({
+				catch: identity,
+				try: () => Promise.resolve(result)
+			})), Effect.onInterrupt(() => Effect.sync(() => controller.abort())));
+		});
+		return this.#withRetry(once);
+	}
+	#withRetry(once) {
+		const retry = this.#behavior("retry") ?? (this.#host.isServer ? 0 : 3);
+		const countFailure = Effect.sync(() => this.#set({ failureCount: this.#state.failureCount + 1 }));
+		const counted = once.pipe(Effect.tapError(() => countFailure));
+		if (Schedule.isSchedule(retry)) return Effect.retry(counted, retry);
+		const retryDelay = this.#behavior("retryDelay");
+		const delayFor = (failureCount, error) => {
+			if (retryDelay === void 0) return Math.min(1e3 * 2 ** (failureCount - 1), 3e4);
+			return Predicate.isNumber(retryDelay) ? retryDelay : retryDelay(failureCount, error);
+		};
+		const attempt = counted.pipe(Effect.catch((error) => {
+			const failureCount = this.#state.failureCount;
+			if (!shouldRetry(retry, failureCount, error)) return Effect.fail(error);
+			return Effect.sleep(delayFor(failureCount, error)).pipe(Effect.andThen(Effect.suspend(() => attempt)));
+		}));
+		return attempt;
+	}
+	#clearGc() {
+		clearTimeout(this.#gcTimer);
+		this.#gcTimer = void 0;
+	}
+	#scheduleGc() {
+		this.#clearGc();
+		if (this.isObserved || this.#inFlight) return;
+		const gcTime = this.#behavior("gcTime") ?? (this.#host.isServer ? Infinity : 3e5);
+		if (Number.isFinite(gcTime)) this.#gcTimer = setTimeout(() => this.#host.remove(this), gcTime);
+	}
+	#scheduleStale() {
+		clearTimeout(this.#staleTimer);
+		const state = this.#state;
+		if (this.#host.isServer || !this.isObserved || state.isStale) return;
+		const staleTime = this.#behavior("staleTime") ?? 0;
+		if (!Number.isFinite(staleTime)) return;
+		const remaining = state.updatedAt + staleTime - Date.now();
+		this.#staleTimer = setTimeout(() => this.#set({}), Math.max(remaining, 0) + 1);
+	}
+};
+//#endregion
+export { CancelledError, QueryEntry, isInfiniteData, nextPageParam, previousPageParam };

package/dist/thenable.mjs

@@ -0,0 +1,37 @@
+//#region src/thenable.ts
+/**
+* Promises that React's `use()` can read synchronously. React checks
+* `status` / `value` / `reason` on a thenable before suspending, so a
+* settled one renders without a fallback.
+*/
+const noop = () => {};
+function fulfilled(value) {
+	return Object.assign(Promise.resolve(value), {
+		status: "fulfilled",
+		value
+	});
+}
+function pending() {
+	const deferred = Promise.withResolvers();
+	const promise = Object.assign(deferred.promise, { status: "pending" });
+	promise.catch(noop);
+	return {
+		promise,
+		reject(reason) {
+			Object.assign(promise, {
+				reason,
+				status: "rejected"
+			});
+			deferred.reject(reason);
+		},
+		resolve(value) {
+			Object.assign(promise, {
+				status: "fulfilled",
+				value
+			});
+			deferred.resolve(value);
+		}
+	};
+}
+//#endregion
+export { fulfilled, pending };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raf-query/core",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Framework-agnostic core of raf-query, a render-as-you-fetch query library",
   "keywords": [
     "query",