@raf-query/core 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -1,10 +1,16 @@
 # Changelog
 
+## [0.1.3](https://github.com/KATT/raf-query/compare/0.1.2...0.1.3) (2026-10-12)
+
+### Features
+
+* **core:** cancel requests nobody reads anymore ([#27](https://github.com/KATT/raf-query/issues/27)) ([c3c1e4b](https://github.com/KATT/raf-query/commit/c3c1e4bb9250164b6df17d7d4b7bd4043f908961))
+
 ## [0.1.2](https://github.com/KATT/raf-query/compare/0.1.1...0.1.2) (2026-10-12)
 
 ### Features
 
-* add isFetching(filter?) and useIsFetching(filter?) ([#25](https://github.com/KATT/raf-query/issues/25)) ([70c3b98](https://github.com/KATT/raf-query/commit/70c3b981027f717b1d619d5a2b23822f685c032a))
+- add isFetching(filter?) and useIsFetching(filter?) ([#25](https://github.com/KATT/raf-query/issues/25)) ([70c3b98](https://github.com/KATT/raf-query/commit/70c3b981027f717b1d619d5a2b23822f685c032a))
 
 ## [0.1.1](https://github.com/KATT/raf-query/compare/0.1.0...0.1.1) (2026-10-12)
 

package/README.md

@@ -644,6 +644,8 @@ Query options, accepted by `queryOptions`, `infiniteQueryOptions` and `config.de
 
 In the browser, retries pause while `navigator.onLine` is `false`: after the retry delay, the next attempt waits for the window's `online` event. The request stays fetching meanwhile, and cancelling it (`remove`, `clear`, a restart) stops the wait. The first attempt runs regardless.
 
+When the last reader of a query unsubscribes during a background refetch, a `queryFn` that read its `signal` (or returned an Effect) is aborted: the entry keeps its data and goes back to how it was before the request, and `fetch` callers waiting on it get the cached data. Other requests, including every first load (a render may be suspended on it), finish so their result is cached, but don't retry unless a reader comes back. Requests nothing has subscribed to yet, like a loader's `prefetch`, keep running.
+
 `@raf-query/core`:
 
 | Export                                                       | Use                                                                        |

package/dist/entry.d.mts

@@ -54,6 +54,8 @@ export interface Entry extends Query {
   readonly commands: Commands;
   /** A failed first load was shown; the next read retries it. */
   errorShown: boolean;
+  /** `failureCount` before the request in flight, restored if it's cancelled. */
+  failureCountBefore: number;
   handle: QueryHandle;
   /** Awaited by every caller of the request in flight; outlives restarts. */
   inFlight: Deferred.Deferred<unknown, unknown> | undefined;
@@ -61,6 +63,8 @@ export interface Entry extends Query {
   options: AnyQueryOptions | undefined;
   /** The first load's promise, until it settles. */
   pending: Pending<unknown> | undefined;
+  /** The last reader left during the request in flight: it retries no more. */
+  retriesStopped: boolean;
   /** Open while the entry is cached; owns its fibers. */
   readonly scope: Scope.Closeable;
   /**
@@ -68,6 +72,11 @@ export interface Entry extends Query {
    * latest verb that called for this entry ({@link provide}).
    */
   services: Context.Context<never>;
+  /**
+   * The request in flight read its `signal`, or returned an Effect, so
+   * interrupting it cancels its work (TanStack's `abortSignalConsumed`).
+   */
+  signalRead: boolean;
   state: State<unknown>;
   readonly tasks: Tasks;
 }

package/dist/entry.mjs

@@ -7,7 +7,7 @@ import { fromQueryFn, requestServices, runRequest } from "./request.mjs";
 import { retrySchedule } from "./retry.mjs";
 import { replaceEqualDeep } from "./share.mjs";
 import { fulfilled, pending } from "./thenable.mjs";
-import { Cause, Data, Deferred, Effect, Exit, FiberMap, Pipeable, Predicate, Scope } from "effect";
+import { Cause, Data, Deferred, Effect, Exit, FiberMap, Pipeable, Predicate, Schedule, Scope } from "effect";
 //#region src/entry.ts
 const TypeId = "~@raf-query/core/Query";
 /**
@@ -55,6 +55,7 @@ function make(cache, key, hash) {
 	const entry = Object.assign(Object.create(Proto), {
 		cache,
 		errorShown: false,
+		failureCountBefore: 0,
 		handle: {
 			input: void 0,
 			key
@@ -65,8 +66,10 @@ function make(cache, key, hash) {
 		listeners: /* @__PURE__ */ new Map(),
 		options: void 0,
 		pending: first,
+		retriesStopped: false,
 		scope,
 		services: cache.services,
+		signalRead: false,
 		state: {
 			data: void 0,
 			error: null,
@@ -121,6 +124,7 @@ function hasPreviousPageUnsafe(entry) {
 }
 function subscribeUnsafe(entry, listener, options = defaultSubscribeOptions) {
 	entry.listeners.set(listener, options);
+	entry.retriesStopped = false;
 	entry.tasks.cancel("gc");
 	scheduleStale(entry);
 	emit(entry.cache, {
@@ -132,6 +136,8 @@ function subscribeUnsafe(entry, listener, options = defaultSubscribeOptions) {
 		if (entry.listeners.size === 0) {
 			entry.tasks.cancel("stale");
 			scheduleGc(entry);
+			const inFlight = entry.inFlight;
+			if (inFlight) scheduleNotify(() => unobserved(entry, inFlight));
 		}
 		emit(entry.cache, {
 			query: entry,
@@ -273,8 +279,11 @@ function set(entry, patch) {
 }
 /** Run `request` as the entry's request fiber, settling into its awaiter. */
 function startRequest(entry, request, direction) {
+	if (!entry.inFlight) entry.failureCountBefore = entry.state.failureCount;
 	const awaiter = entry.inFlight ?? Deferred.makeUnsafe();
 	entry.inFlight = awaiter;
+	entry.retriesStopped = false;
+	entry.signalRead = false;
 	entry.tasks.cancel("gc");
 	if (!entry.state.hasData && entry.state.status === "error") {
 		entry.pending = pending();
@@ -312,6 +321,29 @@ function settle(entry, awaiter, exit) {
 	}
 	scheduleGc(entry);
 }
+/**
+* The last reader left while `awaiter`'s request was in flight. A refetch
+* whose work an interrupt cancels (`signalRead`) is interrupted, and the
+* entry goes back to its state before the request; its awaiters get the
+* cached data. Any other request finishes, so its result is cached, but
+* runs no more retries.
+*/
+function unobserved(entry, awaiter) {
+	if (isObserved(entry) || entry.inFlight !== awaiter) return;
+	if (!entry.signalRead || !entry.state.hasData) {
+		entry.retriesStopped = true;
+		return;
+	}
+	entry.inFlight = void 0;
+	entry.tasks.cancel("request");
+	set(entry, {
+		failureCount: entry.failureCountBefore,
+		fetchDirection: void 0,
+		isFetching: false
+	});
+	Deferred.doneUnsafe(awaiter, Exit.succeed(entry.state.data));
+	scheduleGc(entry);
+}
 function succeed(entry, next, updatedAt) {
 	const previous = entry.state;
 	const data = previous.hasData && behavior(entry, "structuralSharing") !== false ? replaceEqualDeep(previous.data, next) : next;
@@ -365,24 +397,37 @@ function markErrorShown(entry) {
 }
 function requestEffect(entry, options, request) {
 	const queryKey = options.queryKey;
-	if (options.kind === "query") return attempt(entry, (signal) => options.queryFn({
+	if (options.kind === "query") return attempt(entry, (readSignal) => options.queryFn({
 		queryKey,
-		signal
+		get signal() {
+			return readSignal();
+		}
 	}));
 	const current = isInfiniteData(entry.state.data) ? entry.state.data : void 0;
-	return fetchPages(options, current, request, (pageParam, direction) => attempt(entry, (signal) => options.queryFn({
+	return fetchPages(options, current, request, (pageParam, direction) => attempt(entry, (readSignal) => options.queryFn({
 		direction,
 		pageParam,
 		queryKey,
-		signal
+		get signal() {
+			return readSignal();
+		}
 	})));
 }
 /**
 * One `queryFn` call, retried per the query's policy. Every failure counts.
-* Its services are erased with its data type; `runRequest` provides them.
+* `call` reads the signal through `readSignal`, which marks the entry's
+* `signalRead`. Its services are erased with its data type; `runRequest`
+* provides them.
 */
 function attempt(entry, call) {
-	const once = fromQueryFn(call).pipe(Effect.tapError(() => Effect.sync(() => set(entry, { failureCount: entry.state.failureCount + 1 }))));
+	const once = fromQueryFn((signal) => {
+		const result = call(() => {
+			entry.signalRead = true;
+			return signal;
+		});
+		if (Effect.isEffect(result)) entry.signalRead = true;
+		return result;
+	}).pipe(Effect.tapError(() => Effect.sync(() => set(entry, { failureCount: entry.state.failureCount + 1 }))));
 	const schedule = retrySchedule({
 		retry: behavior(entry, "retry"),
 		retryDelay: behavior(entry, "retryDelay")
@@ -391,12 +436,18 @@ function attempt(entry, call) {
 	const online = entry.cache.isServer ? Effect.void : whenOnline;
 	return Effect.suspend(() => {
 		let retrying = false;
+		let lastError;
+		const unlessStopped = (next) => Effect.suspend(() => entry.retriesStopped ? Effect.fail(lastError) : next);
 		const gated = Effect.suspend(() => {
-			const wait = retrying ? online : Effect.void;
-			retrying = true;
-			return Effect.andThen(wait, once);
-		});
-		return Effect.retry(gated, schedule);
+			if (!retrying) {
+				retrying = true;
+				return once;
+			}
+			return unlessStopped(Effect.andThen(online, unlessStopped(once)));
+		}).pipe(Effect.tapError((error) => Effect.sync(() => {
+			lastError = error;
+		})));
+		return Effect.retry(gated, Schedule.while(schedule, () => !entry.retriesStopped));
 	});
 }
 function scheduleGc(entry) {

package/package.json

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