kitcn 0.17.1 → 0.17.2

package/dist/solid/index.js

@@ -1,10 +1,10 @@
 import { getFunctionName } from "convex/server";
-import { Show, createContext, createEffect, createMemo, createSignal, on, onCleanup, onMount, useContext } from "solid-js";
+import { Show, createComputed, createContext, createEffect, createMemo, createRenderEffect, createSignal, on, onCleanup, onMount, useContext } from "solid-js";
 import { createComponent, memo } from "solid-js/web";
 import { createStore } from "solid-js/store";
-import { notifyManager, skipToken, useQueries, useQueryClient } from "@tanstack/solid-query";
+import { notifyManager, skipToken, useQueryClient } from "@tanstack/solid-query";
 import { ConvexClient, ConvexHttpClient } from "convex/browser";
-import { hashKey } from "@tanstack/query-core";
+import { QueriesObserver, hashKey } from "@tanstack/query-core";
 import { convexToJson } from "convex/values";
 
 //#region src/crpc/error.ts
@@ -2504,6 +2504,42 @@ const getConvexQueryClientSingleton = ({ authStore, convex, queryClient, symbolK
 //#region src/internal/pagination.ts
 const shouldSplitPaginationPage = (page, initialNumItems) => Boolean(page.splitCursor) && (page.pageStatus === "SplitRecommended" || page.pageStatus === "SplitRequired" || initialNumItems !== void 0 && page.page.length > initialNumItems * 2);
 
+//#endregion
+//#region src/solid/create-queries-results.ts
+/**
+* Subscribe a reactive list of queries and expose the raw observer results.
+*
+* Solid Query's `useQueries` cannot back an aggregate result: it feeds the
+* `combine` output straight into `createStore` and then calls `.map()` on it,
+* so any non-array aggregate throws `state.map is not a function` while the
+* component is still setting up. It also routes `.data` through
+* `createResource`, which suspends the nearest boundary for as long as a query
+* is in flight.
+*
+* Driving `QueriesObserver` directly keeps every entry a plain
+* `QueryObserverResult` - the same value the React port aggregates - and leaves
+* aggregation to the caller.
+*
+* @param queries Reactive list of query options.
+* @returns Accessor for the raw observer results, in query order.
+*/
+function createQueriesResults(queries) {
+	const queryClient = useQueryClient();
+	const defaulted = () => queries().map((options) => ({
+		...queryClient.defaultQueryOptions(options),
+		_optimisticResults: "optimistic"
+	}));
+	const observer = new QueriesObserver(queryClient, defaulted());
+	const [results, setResults] = createSignal(observer.getCurrentResult(), { equals: false });
+	createComputed(() => {
+		const next = defaulted();
+		observer.setQueries(next);
+		setResults(observer.getOptimisticResult(next, void 0)[0]);
+	});
+	onCleanup(observer.subscribe((next) => setResults(next)));
+	return results;
+}
+
 //#endregion
 //#region src/solid/use-infinite-query.ts
 const PAGINATION_KEY_PREFIX = "__pagination__";
@@ -2516,6 +2552,59 @@ const getOrCreatePaginationId = (storeKey) => {
 	paginationIdStore.set(storeKey, newId);
 	return newId;
 };
+/** Read the identity of a Convex document, tolerating `id` and `_id` shapes */
+const getItemId = (item) => {
+	const doc = item;
+	return doc?._id || doc?.id;
+};
+/**
+* Fold the per-page observer results into one pagination-shaped aggregate.
+* Pure: same inputs always produce the same output, so it is safe to re-run
+* inside a reactive derivation.
+*/
+const aggregatePages = (results, hasPlaceholderData) => {
+	const allItems = [];
+	const pages = [];
+	const seenIds = /* @__PURE__ */ new Set();
+	let lastPage;
+	let status = "LoadingFirstPage";
+	for (let i = 0; i < results.length; i++) {
+		const pageQuery = results[i];
+		if (pageQuery.isLoading || pageQuery.data === void 0) {
+			status = i === 0 ? "LoadingFirstPage" : "LoadingMore";
+			break;
+		}
+		const page = pageQuery.data;
+		lastPage = page;
+		pages.push(page.page);
+		for (const item of page.page) {
+			const id = getItemId(item);
+			if (id && seenIds.has(id)) continue;
+			if (id) seenIds.add(id);
+			allItems.push(item);
+		}
+		status = page.isDone ? "Exhausted" : "CanLoadMore";
+	}
+	const firstPage = results.length > 0 ? results[0] : void 0;
+	const isPlaceholderData = firstPage ? firstPage.isPlaceholderData : hasPlaceholderData;
+	const isFetching = results.some((r) => r.isFetching);
+	const error = results.find((r) => r.isError)?.error ?? null;
+	return {
+		data: allItems,
+		dataUpdatedAt: Math.max(...results.map((r) => r.dataUpdatedAt)),
+		error,
+		failureReason: error,
+		isError: results.some((r) => r.isError),
+		isFetchNextPageError: results.length > 1 && (results.at(-1)?.isError ?? false),
+		isFetching,
+		isLoading: status === "LoadingFirstPage",
+		isPlaceholderData,
+		isRefetching: isFetching && allItems.length > 0 && !isPlaceholderData,
+		lastPage,
+		pages,
+		status
+	};
+};
 /** Build a unique key for recovery attempt detection */
 const buildRecoveryKey = (pageKeys, page0Cursor, page0UpdatedAt) => JSON.stringify({
 	pageKeys,
@@ -2531,26 +2620,27 @@ const buildRecoveryKey = (pageKeys, page0Cursor, page0UpdatedAt) => JSON.stringi
 * This hook detects this pattern and creates a recovery page that fetches
 * enough items to cover the lost pages, preserving the user's scroll position.
 */
-const useStaleCursorRecovery = ({ argsObject, combined, limit, setState, state }) => {
+const useStaleCursorRecovery = ({ argsObject, combined, limit, pageResults, setState, state }) => {
 	createEffect(on([
 		() => combined.isFetchNextPageError,
-		() => combined._rawResults,
+		pageResults,
 		() => state().pageKeys,
 		() => state().queries,
 		() => state().autoRecoveryAttempted,
 		argsObject
 	], () => {
 		if (!combined.isFetchNextPageError) return;
-		const page0Result = combined._rawResults[0];
+		const results = pageResults();
+		const page0Result = results[0];
 		const page0Data = page0Result?.data;
 		const page0UpdatedAt = page0Result?.dataUpdatedAt ?? 0;
 		const hasPage0Data = page0Data !== void 0 && !page0Result?.isError;
-		const hasSubsequentErrors = combined._rawResults.slice(1).some((q) => q?.isError && !q?.isFetching);
+		const hasSubsequentErrors = results.slice(1).some((q) => q?.isError && !q?.isFetching);
 		if (!hasPage0Data || !hasSubsequentErrors || !page0Data?.continueCursor) return;
 		const currentState = state();
 		const recoveryKey = buildRecoveryKey(currentState.pageKeys, page0Data.continueCursor, page0UpdatedAt);
 		if (currentState.autoRecoveryAttempted === recoveryKey) return;
-		const erroredPageKeys = currentState.pageKeys.filter((_, i) => i > 0 && combined._rawResults[i]?.isError);
+		const erroredPageKeys = currentState.pageKeys.filter((_, i) => i > 0 && results[i]?.isError);
 		const itemsToRecover = erroredPageKeys.reduce((sum, key) => {
 			return sum + (currentState.queries[key]?.args?.limit ?? limit ?? 20);
 		}, 0);
@@ -2711,66 +2801,27 @@ const useInfiniteQueryInternal = (query, args, options) => {
 			} } : {}
 		};
 	}));
-	const combined = useQueries(() => ({
-		queries: tanstackQueries(),
-		combine: (results) => {
-			const allItems = [];
-			const pages = [];
-			const seenIds = /* @__PURE__ */ new Set();
-			let lastPage;
-			let paginationStatus = "LoadingFirstPage";
-			for (let i = 0; i < results.length; i++) {
-				const pageQuery = results[i];
-				if (pageQuery.isLoading || pageQuery.data === void 0) {
-					paginationStatus = i === 0 ? "LoadingFirstPage" : "LoadingMore";
-					break;
-				}
-				const page = pageQuery.data;
-				lastPage = page;
-				pages.push(page.page);
-				for (const item of page.page) {
-					const id = item._id || item.id;
-					if (id && seenIds.has(id)) continue;
-					if (id) seenIds.add(id);
-					allItems.push(item);
-				}
-				paginationStatus = page.isDone ? "Exhausted" : "CanLoadMore";
-			}
-			const isPlaceholderData = results[0]?.isPlaceholderData ?? !!placeholderData;
-			const isFetching = results.some((r) => r.isFetching);
-			return {
-				data: allItems,
-				dataUpdatedAt: Math.max(...results.map((r) => r.dataUpdatedAt ?? 0)),
-				lastPage,
-				pages,
-				status: paginationStatus,
-				error: results.find((r) => r.isError)?.error ?? null,
-				isError: results.some((r) => r.isError),
-				isFetching,
-				isFetchNextPageError: results.length > 1 && (results.at(-1)?.isError ?? false),
-				isPlaceholderData,
-				isRefetching: isFetching && allItems.length > 0 && !isPlaceholderData,
-				isLoading: paginationStatus === "LoadingFirstPage",
-				failureReason: results.find((r) => r.isError)?.error ?? null,
-				_rawResults: results
-			};
-		}
-	}));
+	const pageResults = createQueriesResults(() => tanstackQueries());
+	const derive = () => aggregatePages(pageResults(), !!placeholderData);
+	const [combined, setCombined] = createStore(derive());
+	createRenderEffect(() => setCombined(derive()));
 	useStaleCursorRecovery({
 		argsObject,
 		combined,
 		limit,
+		pageResults,
 		setState,
 		state
 	});
 	createEffect(on([
-		() => combined._rawResults,
+		pageResults,
 		() => state().pageKeys,
 		() => state().queries,
 		argsObject
 	], () => {
-		for (let i = 0; i < combined._rawResults.length; i++) {
-			const pageQuery = combined._rawResults[i];
+		const results = pageResults();
+		for (let i = 0; i < results.length; i++) {
+			const pageQuery = results[i];
 			if (pageQuery.data) {
 				const page = pageQuery.data;
 				const pageKey = state().pageKeys[i];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kitcn",
-  "version": "0.17.1",
+  "version": "0.17.2",
   "description": "kitcn - React Query integration and CLI tools for Convex",
   "keywords": [
     "convex",