@raf-query/core 0.0.19 → 0.1.0

package/dist/hydration.mjs

@@ -1,15 +1,25 @@
-import { cacheOf } from "./client.mjs";
+import { resume, setData } from "./entry.mjs";
+import { getUnsafe } from "./query.mjs";
+import { Data, Effect, Queue, Stream } from "effect";
 //#region src/hydration.ts
+/**
+* What a dehydrated pending query rejects with when its request failed and
+* `keepErrors` is off: the receiving side learns which query failed, not why.
+*/
+var RedactedError = class extends Data.TaggedError("RedactedError") {
+	get message() {
+		return `Query ${this.hash} failed`;
+	}
+};
 const noop = () => {};
 const identity = (value) => value;
 /** The default dehydrate filter: entries with data or a request in flight. */
 function canDehydrate(query) {
-	const state = query.getState();
+	const state = getUnsafe(query);
 	return state.hasData || state.isFetching;
 }
-/** Snapshot one entry for transfer. */
-function dehydrateQuery(query, options = {}) {
-	const state = query.getState();
+function dehydrateUnsafe(query, options) {
+	const state = getUnsafe(query);
 	const serialize = options.serializeData ?? identity;
 	if (state.hasData) return {
 		data: serialize(state.data),
@@ -17,7 +27,7 @@ function dehydrateQuery(query, options = {}) {
 		updatedAt: state.updatedAt
 	};
 	const promise = state.promise.then(serialize, (error) => {
-		throw options.keepErrors ? error : /* @__PURE__ */ new Error(`Query ${query.hash} failed`);
+		throw options.keepErrors ? error : new RedactedError({ hash: query.hash });
 	});
 	promise.catch(noop);
 	return {
@@ -26,25 +36,76 @@ function dehydrateQuery(query, options = {}) {
 		updatedAt: 0
 	};
 }
-/** Snapshot the cache for transfer to another client (server → browser). */
-function dehydrate(client, options = {}) {
+/** Snapshot one entry for transfer. */
+function dehydrateQuery(query, options = {}) {
+	return Effect.sync(() => dehydrateUnsafe(query, options));
+}
+/** Dehydrate the entries `options` selects, recording them in `options.sent`. */
+function dehydrateEntries(queries, options) {
 	const filter = options.filter ?? canDehydrate;
-	return { queries: client.getAll().filter(filter).map((query) => dehydrateQuery(query, options)) };
+	const sent = options.sent;
+	const dehydrated = [];
+	for (const query of queries) if (!sent?.has(query.hash) && filter(query)) {
+		sent?.add(query.hash);
+		dehydrated.push(dehydrateUnsafe(query, options));
+	}
+	return { queries: dehydrated };
 }
 /**
-* Write dehydrated entries into a client. Existing entries only take newer
+* Snapshots `queries()` and subscribes in the same synchronous step, so no
+* change falls between the two. Changed entries are collected for a
+* microtask, so entries that settle together share a batch, and the batch is
+* handed to the reader before that microtask ends: ahead of the Suspense
+* boundaries React resumes for those entries.
+*/
+const dehydrateStream = Effect.fnUntraced(function* (queries, subscribe, options) {
+	const sent = options.sent ?? /* @__PURE__ */ new Set();
+	const send = {
+		...options,
+		sent
+	};
+	const queue = yield* Queue.unbounded();
+	let batch;
+	const flush = () => {
+		const changed = batch;
+		batch = void 0;
+		if (!changed) return;
+		const state = dehydrateEntries(changed.values(), send);
+		if (state.queries.length > 0) {
+			Queue.offerUnsafe(queue, state);
+			Queue.flushUnsafe(queue);
+		}
+	};
+	yield* Effect.acquireRelease(Effect.sync(() => subscribe((event) => {
+		if (event.type === "removed" || sent.has(event.query.hash)) return;
+		if (!batch) {
+			batch = /* @__PURE__ */ new Map();
+			queueMicrotask(flush);
+		}
+		batch.set(event.query.hash, event.query);
+	})), (unsubscribe) => Effect.sync(() => {
+		flush();
+		unsubscribe();
+		Queue.endUnsafe(queue);
+	}));
+	return {
+		initial: dehydrateEntries(queries(), send),
+		updates: Stream.fromQueue(queue)
+	};
+});
+/**
+* Write dehydrated entries into a cache. Existing entries only take newer
 * data; pending entries resume the sender's request.
 */
-function hydrate(client, state, options = {}) {
+function hydrateEntries(entryFor, state, options) {
 	const deserialize = options.deserializeData ?? identity;
-	const cache = cacheOf(client);
 	for (const query of state.queries) {
-		const entry = cache.entryFor(query.key);
-		const current = entry.getState();
+		const entry = entryFor(query.key);
+		const current = entry.state;
 		if (query.updatedAt > 0) {
-			if (!current.hasData || current.updatedAt < query.updatedAt) entry.setData(deserialize(query.data), query.updatedAt);
-		} else if (query.promise && !current.hasData) entry.resume(Promise.resolve(query.promise).then(deserialize));
+			if (!current.hasData || current.updatedAt < query.updatedAt) setData(entry, deserialize(query.data), query.updatedAt);
+		} else if (query.promise && !current.hasData) resume(entry, Promise.resolve(query.promise).then(deserialize));
 	}
 }
 //#endregion
-export { canDehydrate, dehydrate, dehydrateQuery, hydrate };
+export { RedactedError, canDehydrate, dehydrateEntries, dehydrateQuery, dehydrateStream, dehydrateUnsafe, hydrateEntries };

package/dist/index.d.mts

@@ -1,9 +1,9 @@
-import { Settled, allKeyed } from "./all-keyed.mjs";
+import { platform_d_exports } from "./platform.mjs";
 import { QueryKey, hashKey, matchesKey } from "./key.mjs";
-import { AnyQueryOptions, DataOf, EnsuredQueryHandle, InfiniteData, InfiniteQueryOptions, InputArgs, InputOf, IsPaged, LoadOptions, PageFunctionContext, PageOf, QueryBehavior, QueryFactory, QueryFnResult, QueryFunctionContext, QueryHandle, QueryOptions, RetryPolicy, infiniteQueryOptions, queryOptions } from "./options.mjs";
+import { AnyQueryOptions, DataOf, EnsuredQueryHandle, ErrorOf, InfiniteData, InfiniteQueryOptions, InputArgs, InputOf, IsPaged, LoadOptions, PageFunctionContext, PageOf, QueryBehavior, QueryFactory, QueryFnResult, QueryFunctionContext, QueryHandle, QueryOptions, RetryPolicy, ServicesOf, infiniteQueryOptions, queryOptions } from "./options.mjs";
+import { DehydrateOptions, DehydratedQuery, DehydratedState, DehydratedStream, HydrateOptions, RedactedError, canDehydrate, dehydrateQuery } from "./hydration.mjs";
+import { cache_d_exports } from "./cache.mjs";
 import { Thenable } from "./thenable.mjs";
-import { CancelledError, FetchRequest, Query, QueryState, SubscribeOptions } from "./query.mjs";
-import { CacheEvent, LoadArgs, QueryClient, QueryClientConfig, QueryClientEffect, QueryFilter, Updater } from "./client.mjs";
-import { DehydrateOptions, DehydratedQuery, DehydratedState, HydrateOptions, canDehydrate, dehydrate, dehydrateQuery, hydrate } from "./hydration.mjs";
-import { QueryObserver, QueryObserverOptions, QueryObserverResult } from "./observer.mjs";
-export { type AnyQueryOptions, type CacheEvent, CancelledError, type DataOf, type DehydrateOptions, type DehydratedQuery, type DehydratedState, type EnsuredQueryHandle, type FetchRequest, type HydrateOptions, type InfiniteData, type InfiniteQueryOptions, type InputArgs, type InputOf, type IsPaged, type LoadArgs, type LoadOptions, type PageFunctionContext, type PageOf, type Query, type QueryBehavior, QueryClient, type QueryClientConfig, type QueryClientEffect, type QueryFactory, type QueryFilter, type QueryFnResult, type QueryFunctionContext, type QueryHandle, type QueryKey, QueryObserver, type QueryObserverOptions, type QueryObserverResult, type QueryOptions, type QueryState, type RetryPolicy, type Settled, type SubscribeOptions, type Thenable, type Updater, allKeyed, canDehydrate, dehydrate, dehydrateQuery, hashKey, hydrate, infiniteQueryOptions, matchesKey, queryOptions };
+import { query_d_exports } from "./query.mjs";
+import { observer_d_exports } from "./observer.mjs";
+export { type AnyQueryOptions, type DataOf, type DehydrateOptions, type DehydratedQuery, type DehydratedState, type DehydratedStream, type EnsuredQueryHandle, type ErrorOf, type HydrateOptions, type InfiniteData, type InfiniteQueryOptions, type InputArgs, type InputOf, type IsPaged, type LoadOptions, type PageFunctionContext, type PageOf, platform_d_exports as Platform, query_d_exports as Query, type QueryBehavior, cache_d_exports as QueryCache, type QueryFactory, type QueryFnResult, type QueryFunctionContext, type QueryHandle, type QueryKey, observer_d_exports as QueryObserver, type QueryOptions, RedactedError, type RetryPolicy, type ServicesOf, type Thenable, canDehydrate, dehydrateQuery, hashKey, infiniteQueryOptions, matchesKey, queryOptions };

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import { allKeyed } from "./all-keyed.mjs";
+import { platform_exports } from "./platform.mjs";
 import { hashKey, matchesKey } from "./key.mjs";
+import { query_exports } from "./query.mjs";
+import { RedactedError, canDehydrate, dehydrateQuery } from "./hydration.mjs";
 import { infiniteQueryOptions, queryOptions } from "./options.mjs";
-import { CancelledError } from "./query.mjs";
-import { QueryClient } from "./client.mjs";
-import { canDehydrate, dehydrate, dehydrateQuery, hydrate } from "./hydration.mjs";
-import { QueryObserver } from "./observer.mjs";
-export { CancelledError, QueryClient, QueryObserver, allKeyed, canDehydrate, dehydrate, dehydrateQuery, hashKey, hydrate, infiniteQueryOptions, matchesKey, queryOptions };
+import { cache_exports } from "./cache.mjs";
+import { observer_exports } from "./observer.mjs";
+export { platform_exports as Platform, query_exports as Query, cache_exports as QueryCache, observer_exports as QueryObserver, RedactedError, canDehydrate, dehydrateQuery, hashKey, infiniteQueryOptions, matchesKey, queryOptions };

package/dist/infinite.d.mts

@@ -0,0 +1,5 @@
+import "./options.mjs";
+import { Effect } from "effect";
+//#region src/infinite.d.ts
+export type Direction = "backward" | "forward";
+//#endregion

package/dist/infinite.mjs

@@ -0,0 +1,59 @@
+import { Effect, Predicate } from "effect";
+//#region src/infinite.ts
+function isInfiniteData(data) {
+	return Predicate.hasProperty(data, "pages") && Predicate.hasProperty(data, "pageParams") && Array.isArray(data.pages) && Array.isArray(data.pageParams);
+}
+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)
+	};
+}
+/**
+* A paged query's request. With a `direction`, adds one page at that end of
+* `current`. Otherwise loads from the first page param again: as many pages
+* as `current` has, or `pages` if that's more, stopping at the last page.
+*/
+const fetchPages = Effect.fnUntraced(function* (options, current, request, fetchPage) {
+	if (request.direction && current) {
+		const pageParam = request.direction === "forward" ? nextPageParam(options, current) : previousPageParam(options, current);
+		if (pageParam == null) return current;
+		return addPage(current, yield* fetchPage(pageParam, request.direction), 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;
+});
+//#endregion
+export { fetchPages, isInfiniteData, nextPageParam, previousPageParam };

package/dist/listen.mjs

@@ -0,0 +1,19 @@
+import { Effect, Queue, Stream } from "effect";
+//#region src/listen.ts
+/**
+* A stream of what `subscribe` emits. Subscribes in the consuming fiber as
+* soon as the stream starts, so nothing emitted after that is missed
+* (`Stream.callback` subscribes on a forked fiber, a scheduler tick later),
+* and unsubscribes when the stream ends.
+*/
+function listen(subscribe) {
+	return Stream.unwrap(Effect.gen(function* () {
+		const queue = yield* Queue.unbounded();
+		yield* Effect.acquireRelease(Effect.sync(() => subscribe((value) => {
+			Queue.offerUnsafe(queue, value);
+		})), (unsubscribe) => Effect.sync(unsubscribe));
+		return Stream.fromQueue(queue);
+	}));
+}
+//#endregion
+export { listen };

package/dist/observer.d.mts

@@ -1,10 +1,15 @@
 import { QueryKey } from "./key.mjs";
 import { QueryFactory } from "./options.mjs";
 import { Thenable } from "./thenable.mjs";
-import { Query } from "./query.mjs";
-//#region src/observer.d.ts
+import { Query, query_d_exports } from "./query.mjs";
+import { Effect, Pipeable, Stream } from "effect";
+declare namespace observer_d_exports {
+  export { Options, QueryObserver, Result, ResultKey, TypeId, changes, get, getOptimisticResultUnsafe, getUnsafe, isQueryObserver, make, makeUnsafe, setOptionsUnsafe, subscribeUnsafe, trackProp, trackResult };
+}
+export declare const TypeId = "~@raf-query/core/QueryObserver";
+export type TypeId = typeof TypeId;
 /** How one reader observes its query. */
-export interface QueryObserverOptions {
+export interface Options {
   /** Refetch on this interval (ms) while subscribed and the page is visible. */
   readonly refetchInterval?: number;
   /** Refetch on reconnect while stale. Default: the query's option, else `true`. */
@@ -19,11 +24,13 @@ export interface QueryObserverOptions {
   readonly whilePending?: "previous" | "suspend";
 }
 /** What a reader sees of its query. Replaced, never mutated, on every change. */
-export interface QueryObserverResult<TData = unknown> {
+export interface Result<TData = unknown> {
   /** Error of the last failed request. Existing data stays readable. */
   readonly error: unknown;
-  fetchNextPage(): Promise<void>;
-  fetchPreviousPage(): Promise<void>;
+  /** The query's `fetchNextPage`. */
+  readonly fetchNextPage: Effect.Effect<void>;
+  /** The query's `fetchPreviousPage`. */
+  readonly fetchPreviousPage: Effect.Effect<void>;
   /** Stable string form of the observed query's key. */
   readonly hash: string;
   readonly hasNextPage: boolean;
@@ -42,42 +49,53 @@ export interface QueryObserverResult<TData = unknown> {
   readonly isStale: boolean;
   /** Key of the data in `promise`; differs from the query's while `isPrevious`. */
   readonly key: QueryKey;
-  /** Settles with the data to show; see `QueryState.promise`. */
+  /** Settles with the data to show; see `Query.State.promise`. */
   readonly promise: Thenable<TData>;
-  refetch(): Promise<void>;
+  /** The query's `refetch`. */
+  readonly refetch: Effect.Effect<void>;
   /** When the data in `promise` was fetched (ms since epoch); `0` before that. */
   readonly updatedAt: number;
 }
-type ResultKey = keyof QueryObserverResult;
+export type ResultKey = keyof Result;
+export interface QueryObserver<TData = unknown, TFactory extends QueryFactory = QueryFactory> extends Pipeable.Pipeable {
+  /** The options set by the latest `make` or {@link setOptionsUnsafe}. */
+  readonly options: Options;
+  /** The observed query. */
+  readonly query: Query<TData, TFactory>;
+  readonly [TypeId]: {
+    readonly _A: (_: never) => TData;
+  };
+}
+export declare function isQueryObserver(value: unknown): value is QueryObserver;
+/** Observe `query`. Doesn't subscribe to it until the observer has a listener. */
+export declare function makeUnsafe<TData, TFactory extends QueryFactory>(query: Query<TData, TFactory>, options?: Options): QueryObserver<TData, TFactory>;
+/** {@link makeUnsafe}, as an Effect. */
+export declare function make<TData, TFactory extends QueryFactory>(query: Query<TData, TFactory>, options?: Options): Effect.Effect<QueryObserver<TData, TFactory>>;
+/** The current result. */
+export declare function getUnsafe<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>): Result<TData>;
+/** {@link getUnsafe}, as an Effect. */
+export declare function get<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>): Effect.Effect<Result<TData>>;
 /**
- * One reader of one query at a time, like TanStack Query's `QueryObserver`:
- * it derives the reader's result from the query's state, keeps a previous
- * query's data for `whilePending: "previous"`, runs `refetchInterval`, and
- * notifies its listeners only when a result property they read changed
- * (see {@link QueryObserver.trackResult}). Bindings create one per hook.
+ * The result for `query` with `options` right now, without switching to
+ * them. Bindings call this during render, before `setOptionsUnsafe` commits.
  */
-export declare class QueryObserver<TData = unknown, TFactory extends QueryFactory = QueryFactory> {
-  #private;
-  constructor(query: Query<TData, TFactory>, options?: QueryObserverOptions);
-  /**
-   * The result for `query` with `options` right now, without switching to
-   * it. Bindings call this during render, before `setOptions` commits.
-   */
-  getOptimisticResult(query: Query<TData, TFactory>, options: QueryObserverOptions): QueryObserverResult<TData>;
-  getCurrentResult: () => QueryObserverResult<TData>;
-  /** Observe `query` with `options` from now on. */
-  setOptions(query: Query<TData, TFactory>, options: QueryObserverOptions): void;
-  /** Listen for result changes. The first listener subscribes to the query. */
-  subscribe: (listener: () => void) => (() => void);
-  /**
-   * Wrap `result` so that reading a property marks it tracked. Once any
-   * property is tracked, listeners are only notified when a tracked one
-   * changes.
-   */
-  trackResult<TResult extends QueryObserverResult<TData>>(result: TResult): TResult;
-  /** Mark `name` as read, for bindings that track access themselves. */
-  trackProp(name: ResultKey): void;
-  /** Recompute the result, and notify listeners if a tracked property changed. */
-  updateResult(): void;
-}
-//#endregion
+export declare function getOptimisticResultUnsafe<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>, query: Query<TData, TFactory>, options: Options): Result<TData>;
+/** Observe `query` with `options` from now on. */
+export declare function setOptionsUnsafe<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>, query: Query<TData, TFactory>, options: Options): void;
+/** Listen for result changes. The first listener subscribes to the query. */
+export declare function subscribeUnsafe<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>, listener: () => void): () => void;
+/**
+ * The current result, then every change listeners are notified of. Counts
+ * as a listener while the stream runs, so the query counts as read.
+ */
+export declare function changes<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>): Stream.Stream<Result<TData>>;
+/**
+ * Wrap `result` so that reading a property marks it tracked. Once any
+ * property is tracked, listeners are only notified when a tracked one
+ * changes.
+ */
+export declare function trackResult<TData, TFactory extends QueryFactory, TResult extends Result<TData>>(self: QueryObserver<TData, TFactory>, result: TResult): TResult;
+/** Mark `name` as read, for bindings that track access themselves. */
+export declare function trackProp<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>, name: ResultKey): void;
+//#endregion
+export { observer_d_exports };