@questpie/tanstack-query 2.0.0 → 3.0.1

package/README.md

@@ -1,15 +1,15 @@
 # @questpie/tanstack-query
 
-Type-safe TanStack Query option builders for QUESTPIE — collections, globals, RPC procedures, and realtime streaming.
+Type-safe TanStack Query option builders for QUESTPIE — collections, globals, app routes, and realtime streaming.
 
 ## Features
 
 - **Query Options Factory** — Pre-built `queryOptions()` and `mutationOptions()` for all CRUD operations
-- **RPC Query Options** — Typed `query()` / `mutation()` builders for standalone RPC procedures with nested router support
+- **Route Query Options** — Typed `query()` / `mutation()` builders for app routes with nested path support
 - **Realtime Streaming** — `streamedQuery`-based options for SSE live updates on collections and globals
 - **Batch Operations** — `updateMany` and `deleteMany` mutation builders
 - **SSR Ready** — Prefetch data on the server, hydrate on the client
-- **Full Type Inference** — Types flow from your CMS schema through to query results
+- **Full Type Inference** — Types flow from your app schema through to query results
 
 ## Installation
 
@@ -24,43 +24,45 @@ bun add @questpie/tanstack-query questpie @tanstack/react-query
 ```ts
 import { createClient } from "questpie/client";
 import { createQuestpieQueryOptions } from "@questpie/tanstack-query";
-import type { AppCMS, AppRpc } from "@/questpie/server/cms";
+import type { AppConfig } from "#questpie";
 
-const cmsClient = createClient<AppCMS, AppRpc>({
-  baseURL: "http://localhost:3000",
-  basePath: "/api/cms",
+const appClient = createClient<AppConfig>({
+	baseURL: "http://localhost:3000",
+	basePath: "/api",
 });
 
-export const cmsQueries = createQuestpieQueryOptions(cmsClient);
+export const appQueries = createQuestpieQueryOptions(appClient);
 ```
 
 ### 2. Use in Components
 
 ```tsx
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { cmsQueries } from "@/lib/queries";
+import { appQueries } from "@/lib/queries";
 
 function PostsList() {
-  const { data } = useQuery(
-    cmsQueries.collections.posts.find({ limit: 10 })
-  );
-
-  const queryClient = useQueryClient();
-  const createPost = useMutation({
-    ...cmsQueries.collections.posts.create(),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: cmsQueries.collections.posts.key() });
-    },
-  });
-
-  return (
-    <div>
-      {data?.docs.map((post) => <div key={post.id}>{post.title}</div>)}
-      <button onClick={() => createPost.mutate({ title: "New Post" })}>
-        Create
-      </button>
-    </div>
-  );
+	const { data } = useQuery(appQueries.collections.posts.find({ limit: 10 }));
+
+	const queryClient = useQueryClient();
+	const createPost = useMutation({
+		...appQueries.collections.posts.create(),
+		onSuccess: () => {
+			queryClient.invalidateQueries({
+				queryKey: appQueries.collections.posts.key(),
+			});
+		},
+	});
+
+	return (
+		<div>
+			{data?.docs.map((post) => (
+				<div key={post.id}>{post.title}</div>
+			))}
+			<button onClick={() => createPost.mutate({ title: "New Post" })}>
+				Create
+			</button>
+		</div>
+	);
 }
 ```
 
@@ -68,79 +70,77 @@ function PostsList() {
 
 ```ts
 // Find many (paginated)
-cmsQueries.collections.posts.find({
-  where: { published: { eq: true } },
-  orderBy: { createdAt: "desc" },
-  limit: 10,
-  offset: 0,
-  with: { author: true },
-})
+appQueries.collections.posts.find({
+	where: { published: { eq: true } },
+	orderBy: { createdAt: "desc" },
+	limit: 10,
+	offset: 0,
+	with: { author: true },
+});
 
 // Find one
-cmsQueries.collections.posts.findOne({
-  where: { id: "post-id" },
-  with: { author: true },
-})
+appQueries.collections.posts.findOne({
+	where: { id: "post-id" },
+	with: { author: true },
+});
 
 // Count
-cmsQueries.collections.posts.count({
-  where: { published: { eq: true } },
-})
+appQueries.collections.posts.count({
+	where: { published: { eq: true } },
+});
 
 // Create (mutation)
-cmsQueries.collections.posts.create()
+appQueries.collections.posts.create();
 
 // Update (mutation)
-cmsQueries.collections.posts.update()
+appQueries.collections.posts.update();
 
 // Delete (mutation)
-cmsQueries.collections.posts.delete()
+appQueries.collections.posts.delete();
 
 // Update many (mutation)
-cmsQueries.collections.posts.updateMany()
+appQueries.collections.posts.updateMany();
 
 // Delete many (mutation)
-cmsQueries.collections.posts.deleteMany()
+appQueries.collections.posts.deleteMany();
 
 // Restore soft-deleted (mutation)
-cmsQueries.collections.posts.restore()
+appQueries.collections.posts.restore();
 
 // Query key for invalidation
-cmsQueries.collections.posts.key()
+appQueries.collections.posts.key();
 ```
 
 ## Globals
 
 ```ts
 // Get global value
-cmsQueries.globals.siteSettings.get()
+appQueries.globals.siteSettings.get();
 
 // Update global (mutation)
-cmsQueries.globals.siteSettings.update()
+appQueries.globals.siteSettings.update();
 
 // Query key
-cmsQueries.globals.siteSettings.key()
+appQueries.globals.siteSettings.key();
 ```
 
-## RPC
+## Routes
 
-Full type-safe query/mutation options for standalone RPC procedures:
+Full type-safe query/mutation options for app routes:
 
 ```ts
-// Query options from RPC procedure
+// Query options from route
 const { data } = useQuery(
-  cmsQueries.rpc.dashboard.getStats.query({ period: "week" })
+	appQueries.routes.dashboard.getStats.query({ period: "week" }),
 );
 
-// Mutation options from RPC procedure
-const publish = useMutation(
-  cmsQueries.rpc.posts.publish.mutation()
-);
+// Mutation options from route
+const publish = useMutation(appQueries.routes.posts.publish.mutation());
 publish.mutate({ id: "post_123" });
 
 // Query key for invalidation/prefetch
 queryClient.invalidateQueries({
-  queryKey: cmsQueries.rpc.dashboard.getStats.key({ period: "week" }),
+	queryKey: appQueries.routes.dashboard.getStats.key({ period: "week" }),
 });
 ```
 
@@ -151,17 +151,17 @@ Collection queries support SSE-based live updates via `streamedQuery`:
 ```ts
 // Enable realtime on a query
 const { data } = useQuery(
-  cmsQueries.collections.posts.find(
-    { limit: 10 },
-    { realtime: true }
-  )
+	appQueries.collections.posts.find({ limit: 10 }, { realtime: true }),
 );
 ```
 
 Topic helpers for manual subscription:
 
 ```ts
-import { buildCollectionTopic, buildGlobalTopic } from "@questpie/tanstack-query";
+import {
+	buildCollectionTopic,
+	buildGlobalTopic,
+} from "@questpie/tanstack-query";
 
 const postsTopic = buildCollectionTopic("posts");
 const settingsTopic = buildGlobalTopic("siteSettings");
@@ -174,26 +174,28 @@ const settingsTopic = buildGlobalTopic("siteSettings");
 ```tsx
 import { createFileRoute } from "@tanstack/react-router";
 import { useSuspenseQuery } from "@tanstack/react-query";
-import { cmsQueries } from "@/lib/queries";
+import { appQueries } from "@/lib/queries";
 
 export const Route = createFileRoute("/posts")({
-  loader: async ({ context }) => {
-    await context.queryClient.ensureQueryData(
-      cmsQueries.collections.posts.find({ limit: 10 })
-    );
-  },
-  component: PostsPage,
+	loader: async ({ context }) => {
+		await context.queryClient.ensureQueryData(
+			appQueries.collections.posts.find({ limit: 10 }),
+		);
+	},
+	component: PostsPage,
 });
 
 function PostsPage() {
-  const { data } = useSuspenseQuery(
-    cmsQueries.collections.posts.find({ limit: 10 })
-  );
-  return (
-    <ul>
-      {data.docs.map((post) => <li key={post.id}>{post.title}</li>)}
-    </ul>
-  );
+	const { data } = useSuspenseQuery(
+		appQueries.collections.posts.find({ limit: 10 }),
+	);
+	return (
+		<ul>
+			{data.docs.map((post) => (
+				<li key={post.id}>{post.title}</li>
+			))}
+		</ul>
+	);
 }
 ```
 
@@ -202,18 +204,18 @@ function PostsPage() {
 ```tsx
 import { HydrationBoundary, dehydrate } from "@tanstack/react-query";
 import { getQueryClient } from "@/lib/query-client";
-import { cmsQueries } from "@/lib/queries";
+import { appQueries } from "@/lib/queries";
 
 export default async function PostsPage() {
-  const queryClient = getQueryClient();
-  await queryClient.prefetchQuery(
-    cmsQueries.collections.posts.find({ limit: 10 })
-  );
-  return (
-    <HydrationBoundary state={dehydrate(queryClient)}>
-      <PostsList />
-    </HydrationBoundary>
-  );
+	const queryClient = getQueryClient();
+	await queryClient.prefetchQuery(
+		appQueries.collections.posts.find({ limit: 10 }),
+	);
+	return (
+		<HydrationBoundary state={dehydrate(queryClient)}>
+			<PostsList />
+		</HydrationBoundary>
+	);
 }
 ```
 
@@ -228,9 +230,9 @@ export default async function PostsPage() {
 // Globals
 ["globals", globalName, "get"]
 
-// RPC
-["rpc", ...segments, "query", input]
-["rpc", ...segments, "mutation"]
+// Routes
+["routes", ...segments, "query", input]
+["routes", ...segments, "mutation"]
 ```
 
 ## Documentation

package/dist/index.d.mts

@@ -1,6 +1,5 @@
 import { DefaultError, QueryKey, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
-import { QuestpieClient, RealtimeAPI, TopicConfig, buildCollectionTopic, buildGlobalTopic } from "questpie/client";
-import { Questpie } from "questpie";
+import { QuestpieApp, QuestpieClient, RealtimeAPI, TopicConfig, buildCollectionTopic, buildGlobalTopic } from "questpie/client";
 
 //#region src/index.d.ts
 type QuestpieQueryErrorMap = (error: unknown) => unknown;
@@ -8,6 +7,7 @@ type QuestpieQueryOptionsConfig = {
   keyPrefix?: QueryKey;
   errorMap?: QuestpieQueryErrorMap;
   locale?: string;
+  stage?: string;
 };
 type AnyAsyncFn = (...args: any[]) => Promise<any>;
 type QueryData<TFn extends AnyAsyncFn> = Awaited<ReturnType<TFn>>;
@@ -18,40 +18,55 @@ type KeyBuilder<TFn extends AnyAsyncFn> = HasArgs<TFn> extends false ? () => Que
 type MutationVariables<TFn extends AnyAsyncFn> = HasArgs<TFn> extends false ? void : undefined extends FirstArg<TFn> ? FirstArg<TFn> | void : FirstArg<TFn>;
 type MutationBuilder<TVariables, TData> = () => UseMutationOptions<TData, DefaultError, TVariables>;
 /** Extract collection keys from QuestpieClient */
-type CollectionKeys<TCMS extends Questpie<any>, TRPC extends Record<string, any>> = Extract<keyof QuestpieClient<TCMS, TRPC>["collections"], string>;
+type CollectionKeys<TApp extends QuestpieApp> = Extract<keyof QuestpieClient<TApp>["collections"], string>;
 /** Extract global keys from QuestpieClient */
-type GlobalKeys<TCMS extends Questpie<any>, TRPC extends Record<string, any>> = Extract<keyof QuestpieClient<TCMS, TRPC>["globals"], string>;
-type CollectionFind<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends CollectionKeys<TCMS, TRPC>> = QuestpieClient<TCMS, TRPC>["collections"][K$1]["find"];
-type CollectionCount<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends CollectionKeys<TCMS, TRPC>> = QuestpieClient<TCMS, TRPC>["collections"][K$1]["count"];
-type CollectionFindOne<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends CollectionKeys<TCMS, TRPC>> = QuestpieClient<TCMS, TRPC>["collections"][K$1]["findOne"];
-type CollectionCreate<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends CollectionKeys<TCMS, TRPC>> = QuestpieClient<TCMS, TRPC>["collections"][K$1]["create"];
-type CollectionUpdate<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends CollectionKeys<TCMS, TRPC>> = QuestpieClient<TCMS, TRPC>["collections"][K$1]["update"];
-type CollectionDelete<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends CollectionKeys<TCMS, TRPC>> = QuestpieClient<TCMS, TRPC>["collections"][K$1]["delete"];
-type CollectionRestore<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends CollectionKeys<TCMS, TRPC>> = QuestpieClient<TCMS, TRPC>["collections"][K$1]["restore"];
-type GlobalGet<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends GlobalKeys<TCMS, TRPC>> = QuestpieClient<TCMS, TRPC>["globals"][K$1] extends {
+type GlobalKeys<TApp extends QuestpieApp> = Extract<keyof QuestpieClient<TApp>["globals"], string>;
+type CollectionFind<TApp extends QuestpieApp, K$1 extends CollectionKeys<TApp>> = QuestpieClient<TApp>["collections"][K$1]["find"];
+type CollectionCount<TApp extends QuestpieApp, K$1 extends CollectionKeys<TApp>> = QuestpieClient<TApp>["collections"][K$1]["count"];
+type CollectionFindOne<TApp extends QuestpieApp, K$1 extends CollectionKeys<TApp>> = QuestpieClient<TApp>["collections"][K$1]["findOne"];
+type CollectionCreate<TApp extends QuestpieApp, K$1 extends CollectionKeys<TApp>> = QuestpieClient<TApp>["collections"][K$1]["create"];
+type CollectionUpdate<TApp extends QuestpieApp, K$1 extends CollectionKeys<TApp>> = QuestpieClient<TApp>["collections"][K$1]["update"];
+type CollectionDelete<TApp extends QuestpieApp, K$1 extends CollectionKeys<TApp>> = QuestpieClient<TApp>["collections"][K$1]["delete"];
+type CollectionRestore<TApp extends QuestpieApp, K$1 extends CollectionKeys<TApp>> = QuestpieClient<TApp>["collections"][K$1]["restore"];
+type CollectionFindVersions<TApp extends QuestpieApp, K$1 extends CollectionKeys<TApp>> = QuestpieClient<TApp>["collections"][K$1]["findVersions"];
+type CollectionRevertToVersion<TApp extends QuestpieApp, K$1 extends CollectionKeys<TApp>> = QuestpieClient<TApp>["collections"][K$1]["revertToVersion"];
+type CollectionTransitionStage<TApp extends QuestpieApp, K$1 extends CollectionKeys<TApp>> = QuestpieClient<TApp>["collections"][K$1]["transitionStage"];
+type GlobalGet<TApp extends QuestpieApp, K$1 extends GlobalKeys<TApp>> = QuestpieClient<TApp>["globals"][K$1] extends {
   get: infer TGet;
 } ? TGet extends AnyAsyncFn ? TGet : never : never;
-type GlobalUpdate<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends GlobalKeys<TCMS, TRPC>> = QuestpieClient<TCMS, TRPC>["globals"][K$1] extends {
+type GlobalUpdate<TApp extends QuestpieApp, K$1 extends GlobalKeys<TApp>> = QuestpieClient<TApp>["globals"][K$1] extends {
   update: infer TUpdate;
 } ? TUpdate extends AnyAsyncFn ? TUpdate : never : never;
-type RpcProcedureQueryOptionsAPI<TFn extends AnyAsyncFn> = {
+type GlobalFindVersions<TApp extends QuestpieApp, K$1 extends GlobalKeys<TApp>> = QuestpieClient<TApp>["globals"][K$1] extends {
+  findVersions: infer TFindVersions;
+} ? TFindVersions extends AnyAsyncFn ? TFindVersions : never : never;
+type GlobalRevertToVersion<TApp extends QuestpieApp, K$1 extends GlobalKeys<TApp>> = QuestpieClient<TApp>["globals"][K$1] extends {
+  revertToVersion: infer TRevert;
+} ? TRevert extends AnyAsyncFn ? TRevert : never : never;
+type GlobalTransitionStage<TApp extends QuestpieApp, K$1 extends GlobalKeys<TApp>> = QuestpieClient<TApp>["globals"][K$1] extends {
+  transitionStage: infer TTransition;
+} ? TTransition extends AnyAsyncFn ? TTransition : never : never;
+type RouteLeafQueryOptionsAPI<TFn extends AnyAsyncFn> = {
   query: QueryBuilder<TFn>;
   mutation: MutationBuilder<MutationVariables<TFn>, QueryData<TFn>>;
   key: KeyBuilder<TFn>;
 };
-type RpcQueryOptionsAPI<TRpcNode> = TRpcNode extends AnyAsyncFn ? RpcProcedureQueryOptionsAPI<TRpcNode> : TRpcNode extends Record<string, any> ? { [K in keyof TRpcNode]: RpcQueryOptionsAPI<TRpcNode[K]> } : never;
-type CollectionQueryOptionsAPI<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends CollectionKeys<TCMS, TRPC>> = {
-  find: QueryBuilder<CollectionFind<TCMS, TRPC, K$1>>;
-  count: QueryBuilder<CollectionCount<TCMS, TRPC, K$1>>;
-  findOne: QueryBuilder<CollectionFindOne<TCMS, TRPC, K$1>>;
-  create: MutationBuilder<FirstArg<CollectionCreate<TCMS, TRPC, K$1>>, QueryData<CollectionCreate<TCMS, TRPC, K$1>>>;
-  update: MutationBuilder<FirstArg<CollectionUpdate<TCMS, TRPC, K$1>>, QueryData<CollectionUpdate<TCMS, TRPC, K$1>>>;
-  delete: MutationBuilder<FirstArg<CollectionDelete<TCMS, TRPC, K$1>>, QueryData<CollectionDelete<TCMS, TRPC, K$1>>>;
-  restore: MutationBuilder<FirstArg<CollectionRestore<TCMS, TRPC, K$1>>, QueryData<CollectionRestore<TCMS, TRPC, K$1>>>;
+type RoutesQueryOptionsAPI<TNode> = TNode extends AnyAsyncFn ? RouteLeafQueryOptionsAPI<TNode> : TNode extends Record<string, any> ? { [K in keyof TNode]: RoutesQueryOptionsAPI<TNode[K]> } : never;
+type CollectionQueryOptionsAPI<TApp extends QuestpieApp, K$1 extends CollectionKeys<TApp>> = {
+  find: QueryBuilder<CollectionFind<TApp, K$1>>;
+  count: QueryBuilder<CollectionCount<TApp, K$1>>;
+  findOne: QueryBuilder<CollectionFindOne<TApp, K$1>>;
+  create: MutationBuilder<FirstArg<CollectionCreate<TApp, K$1>>, QueryData<CollectionCreate<TApp, K$1>>>;
+  update: MutationBuilder<FirstArg<CollectionUpdate<TApp, K$1>>, QueryData<CollectionUpdate<TApp, K$1>>>;
+  delete: MutationBuilder<FirstArg<CollectionDelete<TApp, K$1>>, QueryData<CollectionDelete<TApp, K$1>>>;
+  restore: MutationBuilder<FirstArg<CollectionRestore<TApp, K$1>>, QueryData<CollectionRestore<TApp, K$1>>>;
+  findVersions: QueryBuilder<CollectionFindVersions<TApp, K$1>>;
+  revertToVersion: MutationBuilder<FirstArg<CollectionRevertToVersion<TApp, K$1>>, QueryData<CollectionRevertToVersion<TApp, K$1>>>;
+  transitionStage: MutationBuilder<FirstArg<CollectionTransitionStage<TApp, K$1>>, QueryData<CollectionTransitionStage<TApp, K$1>>>;
   updateMany: MutationBuilder<{
     where: any;
     data: any;
-  }, QueryData<CollectionUpdate<TCMS, TRPC, K$1>>>;
+  }, QueryData<CollectionUpdate<TApp, K$1>>>;
   deleteMany: MutationBuilder<{
     where: any;
   }, {
@@ -59,17 +74,26 @@ type CollectionQueryOptionsAPI<TCMS extends Questpie<any>, TRPC extends Record<s
     count: number;
   }>;
 };
-type GlobalQueryOptionsAPI<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends GlobalKeys<TCMS, TRPC>> = {
-  get: QueryBuilder<GlobalGet<TCMS, TRPC, K$1>>;
+type GlobalQueryOptionsAPI<TApp extends QuestpieApp, K$1 extends GlobalKeys<TApp>> = {
+  get: QueryBuilder<GlobalGet<TApp, K$1>>;
   update: MutationBuilder<{
-    data: Parameters<GlobalUpdate<TCMS, TRPC, K$1>>[0];
-    options?: Parameters<GlobalUpdate<TCMS, TRPC, K$1>>[1];
-  }, QueryData<GlobalUpdate<TCMS, TRPC, K$1>>>;
+    data: Parameters<GlobalUpdate<TApp, K$1>>[0];
+    options?: Parameters<GlobalUpdate<TApp, K$1>>[1];
+  }, QueryData<GlobalUpdate<TApp, K$1>>>;
+  findVersions: QueryBuilder<GlobalFindVersions<TApp, K$1>>;
+  revertToVersion: MutationBuilder<{
+    params: Parameters<GlobalRevertToVersion<TApp, K$1>>[0];
+    options?: Parameters<GlobalRevertToVersion<TApp, K$1>>[1];
+  }, QueryData<GlobalRevertToVersion<TApp, K$1>>>;
+  transitionStage: MutationBuilder<{
+    params: Parameters<GlobalTransitionStage<TApp, K$1>>[0];
+    options?: Parameters<GlobalTransitionStage<TApp, K$1>>[1];
+  }, QueryData<GlobalTransitionStage<TApp, K$1>>>;
 };
-type QuestpieQueryOptionsProxy<TCMS extends Questpie<any>, TRPC extends Record<string, any> = Record<string, never>> = {
-  collections: { [K in CollectionKeys<TCMS, TRPC>]: CollectionQueryOptionsAPI<TCMS, TRPC, K> };
-  globals: { [K in GlobalKeys<TCMS, TRPC>]: GlobalQueryOptionsAPI<TCMS, TRPC, K> };
-  rpc: RpcQueryOptionsAPI<QuestpieClient<TCMS, TRPC>["rpc"]>;
+type QuestpieQueryOptionsProxy<TApp extends QuestpieApp = QuestpieApp> = {
+  collections: { [K in CollectionKeys<TApp>]: CollectionQueryOptionsAPI<TApp, K> };
+  globals: { [K in GlobalKeys<TApp>]: GlobalQueryOptionsAPI<TApp, K> };
+  routes: RoutesQueryOptionsAPI<QuestpieClient<TApp>["routes"]>;
   custom: {
     query: <TData>(config: {
       key: QueryKey;
@@ -89,9 +113,9 @@ type QuestpieQueryOptionsProxy<TCMS extends Questpie<any>, TRPC extends Record<s
  * ```ts
  * import { createQuestpieQueryOptions } from "@questpie/tanstack-query"
  * import { createClient } from "questpie/client"
- * import type { AppCMS, AppRpc } from "@/cms"
+ * import type { App, AppRpc } from "@/app"
  *
- * const client = createClient<AppCMS, AppRpc>({ baseURL: "http://localhost:3000" })
+ * const client = createClient<App, AppRpc>({ baseURL: "http://localhost:3000" })
  * const cmsQueries = createQuestpieQueryOptions(client)
  *
  * // Use with useQuery
@@ -100,10 +124,10 @@ type QuestpieQueryOptionsProxy<TCMS extends Questpie<any>, TRPC extends Record<s
  * // Use with useMutation
  * const mutation = useMutation(cmsQueries.collections.posts.create())
  *
- * // Use with RPC
- * const stats = useQuery(cmsQueries.rpc.dashboard.getStats.query({ period: "week" }))
+ * // Use with routes
+ * const stats = useQuery(cmsQueries.routes.dashboard.getStats.query({ period: "week" }))
  * ```
  */
-declare function createQuestpieQueryOptions<TCMS extends Questpie<any>, TRPC extends Record<string, any> = Record<string, never>>(client: QuestpieClient<TCMS, TRPC>, config?: QuestpieQueryOptionsConfig): QuestpieQueryOptionsProxy<TCMS, TRPC>;
+declare function createQuestpieQueryOptions<TApp extends QuestpieApp = QuestpieApp>(client: QuestpieClient<TApp>, config?: QuestpieQueryOptionsConfig): QuestpieQueryOptionsProxy<TApp>;
 //#endregion
 export { type DefaultError, type QueryKey, QuestpieQueryErrorMap, QuestpieQueryOptionsConfig, QuestpieQueryOptionsProxy, type RealtimeAPI, type TopicConfig, type UseMutationOptions, type UseQueryOptions, buildCollectionTopic, buildGlobalTopic, createQuestpieQueryOptions };

package/dist/index.mjs

@@ -45,9 +45,9 @@ const wrapMutationFn = (mutationFn, errorMap) => {
 * ```ts
 * import { createQuestpieQueryOptions } from "@questpie/tanstack-query"
 * import { createClient } from "questpie/client"
-* import type { AppCMS, AppRpc } from "@/cms"
+* import type { App, AppRpc } from "@/app"
 *
-* const client = createClient<AppCMS, AppRpc>({ baseURL: "http://localhost:3000" })
+* const client = createClient<App, AppRpc>({ baseURL: "http://localhost:3000" })
 * const cmsQueries = createQuestpieQueryOptions(client)
 *
 * // Use with useQuery
@@ -56,14 +56,15 @@ const wrapMutationFn = (mutationFn, errorMap) => {
 * // Use with useMutation
 * const mutation = useMutation(cmsQueries.collections.posts.create())
 *
-* // Use with RPC
-* const stats = useQuery(cmsQueries.rpc.dashboard.getStats.query({ period: "week" }))
+* // Use with routes
+* const stats = useQuery(cmsQueries.routes.dashboard.getStats.query({ period: "week" }))
 * ```
 */
 function createQuestpieQueryOptions(client, config = {}) {
 	const keyPrefix = config.keyPrefix ?? ["questpie"];
 	const errorMap = config.errorMap ?? defaultErrorMap;
 	const locale = config.locale;
+	const stage = config.stage;
 	const collections = new Proxy({}, { get: (_target, collectionName) => {
 		if (typeof collectionName !== "string") return void 0;
 		const collection = client.collections[collectionName];
@@ -74,6 +75,7 @@ function createQuestpieQueryOptions(client, config = {}) {
 					...baseKey,
 					"find",
 					locale,
+					stage,
 					normalizeQueryKeyOptions(options)
 				]);
 				if (queryConfig?.realtime && client.realtime) {
@@ -98,6 +100,7 @@ function createQuestpieQueryOptions(client, config = {}) {
 					...baseKey,
 					"count",
 					locale,
+					stage,
 					normalizeQueryKeyOptions(options)
 				]);
 				if (queryConfig?.realtime && client.realtime) {
@@ -122,6 +125,7 @@ function createQuestpieQueryOptions(client, config = {}) {
 					...baseKey,
 					"findOne",
 					locale,
+					stage,
 					normalizeQueryKeyOptions(options)
 				]),
 				queryFn: wrapQueryFn(() => collection.findOne(options), errorMap)
@@ -130,49 +134,110 @@ function createQuestpieQueryOptions(client, config = {}) {
 				mutationKey: buildKey(keyPrefix, [
 					...baseKey,
 					"create",
-					locale
+					locale,
+					stage
 				]),
-				mutationFn: wrapMutationFn((data) => collection.create(data, locale ? { locale } : void 0), errorMap)
+				mutationFn: wrapMutationFn((data) => collection.create(data, locale || stage ? {
+					...locale ? { locale } : {},
+					...stage ? { stage } : {}
+				} : void 0), errorMap)
 			}),
 			update: () => mutationOptions({
 				mutationKey: buildKey(keyPrefix, [
 					...baseKey,
 					"update",
-					locale
+					locale,
+					stage
 				]),
-				mutationFn: wrapMutationFn((variables) => collection.update(variables, locale ? { locale } : void 0), errorMap)
+				mutationFn: wrapMutationFn((variables) => collection.update(variables, locale || stage ? {
+					...locale ? { locale } : {},
+					...stage ? { stage } : {}
+				} : void 0), errorMap)
 			}),
 			delete: () => mutationOptions({
 				mutationKey: buildKey(keyPrefix, [
 					...baseKey,
 					"delete",
-					locale
+					locale,
+					stage
 				]),
-				mutationFn: wrapMutationFn((variables) => collection.delete(variables, locale ? { locale } : void 0), errorMap)
+				mutationFn: wrapMutationFn((variables) => collection.delete(variables, locale || stage ? {
+					...locale ? { locale } : {},
+					...stage ? { stage } : {}
+				} : void 0), errorMap)
 			}),
 			restore: () => mutationOptions({
 				mutationKey: buildKey(keyPrefix, [
 					...baseKey,
 					"restore",
-					locale
+					locale,
+					stage
+				]),
+				mutationFn: wrapMutationFn((variables) => collection.restore(variables, locale || stage ? {
+					...locale ? { locale } : {},
+					...stage ? { stage } : {}
+				} : void 0), errorMap)
+			}),
+			findVersions: (params) => queryOptions({
+				queryKey: buildKey(keyPrefix, [
+					...baseKey,
+					"findVersions",
+					locale,
+					stage,
+					normalizeQueryKeyOptions(params)
 				]),
-				mutationFn: wrapMutationFn((variables) => collection.restore(variables, locale ? { locale } : void 0), errorMap)
+				queryFn: wrapQueryFn(() => collection.findVersions(params, locale || stage ? {
+					...locale ? { locale } : {},
+					...stage ? { stage } : {}
+				} : void 0), errorMap)
+			}),
+			revertToVersion: () => mutationOptions({
+				mutationKey: buildKey(keyPrefix, [
+					...baseKey,
+					"revertToVersion",
+					locale,
+					stage
+				]),
+				mutationFn: wrapMutationFn((variables) => collection.revertToVersion(variables, locale || stage ? {
+					...locale ? { locale } : {},
+					...stage ? { stage } : {}
+				} : void 0), errorMap)
+			}),
+			transitionStage: () => mutationOptions({
+				mutationKey: buildKey(keyPrefix, [
+					...baseKey,
+					"transitionStage",
+					locale,
+					stage
+				]),
+				mutationFn: wrapMutationFn((variables) => collection.transitionStage(variables, locale || stage ? {
+					...locale ? { locale } : {},
+					...stage ? { stage } : {}
+				} : void 0), errorMap)
 			}),
 			updateMany: () => mutationOptions({
 				mutationKey: buildKey(keyPrefix, [
 					...baseKey,
 					"updateMany",
-					locale
+					locale,
+					stage
 				]),
-				mutationFn: wrapMutationFn((variables) => collection.updateMany(variables, locale ? { locale } : void 0), errorMap)
+				mutationFn: wrapMutationFn((variables) => collection.updateMany(variables, locale || stage ? {
+					...locale ? { locale } : {},
+					...stage ? { stage } : {}
+				} : void 0), errorMap)
 			}),
 			deleteMany: () => mutationOptions({
 				mutationKey: buildKey(keyPrefix, [
 					...baseKey,
 					"deleteMany",
-					locale
+					locale,
+					stage
 				]),
-				mutationFn: wrapMutationFn((variables) => collection.deleteMany(variables, locale ? { locale } : void 0), errorMap)
+				mutationFn: wrapMutationFn((variables) => collection.deleteMany(variables, locale || stage ? {
+					...locale ? { locale } : {},
+					...stage ? { stage } : {}
+				} : void 0), errorMap)
 			})
 		};
 	} });
@@ -186,6 +251,7 @@ function createQuestpieQueryOptions(client, config = {}) {
 					...baseKey,
 					"get",
 					locale,
+					stage,
 					normalizeQueryKeyOptions(options)
 				]);
 				if (queryConfig?.realtime && client.realtime) {
@@ -209,60 +275,104 @@ function createQuestpieQueryOptions(client, config = {}) {
 				mutationKey: buildKey(keyPrefix, [
 					...baseKey,
 					"update",
-					locale
+					locale,
+					stage
 				]),
 				mutationFn: wrapMutationFn((variables) => global.update(variables.data, {
+					...variables.options,
+					...locale ? { locale } : void 0,
+					...stage ? { stage } : void 0
+				}), errorMap)
+			}),
+			findVersions: (options) => queryOptions({
+				queryKey: buildKey(keyPrefix, [
+					...baseKey,
+					"findVersions",
+					locale,
+					stage,
+					normalizeQueryKeyOptions(options)
+				]),
+				queryFn: wrapQueryFn(() => global.findVersions({
+					...options,
+					...locale ? { locale } : void 0,
+					...stage ? { stage } : void 0
+				}), errorMap)
+			}),
+			revertToVersion: () => mutationOptions({
+				mutationKey: buildKey(keyPrefix, [
+					...baseKey,
+					"revertToVersion",
+					locale,
+					stage
+				]),
+				mutationFn: wrapMutationFn((variables) => global.revertToVersion(variables.params, {
+					...variables.options,
+					...locale ? { locale } : void 0,
+					...stage ? { stage } : void 0
+				}), errorMap)
+			}),
+			transitionStage: () => mutationOptions({
+				mutationKey: buildKey(keyPrefix, [
+					...baseKey,
+					"transitionStage",
+					locale,
+					stage
+				]),
+				mutationFn: wrapMutationFn((variables) => global.transitionStage(variables.params, {
 					...variables.options,
 					...locale ? { locale } : void 0
 				}), errorMap)
 			})
 		};
 	} });
-	const callRpcProcedure = async (segments, input) => {
-		let current = client.rpc;
+	/**
+	* Resolve a nested route caller from the client by traversing dot segments.
+	*/
+	const callRoute = async (segments, input) => {
+		let current = client.routes;
 		for (const segment of segments) current = current?.[segment];
-		if (typeof current !== "function") throw new Error(`RPC procedure not found at path: ${segments.join(".") || "<root>"}`);
+		if (typeof current !== "function") throw new Error(`Route not found at path: ${segments.join(".") || "<root>"}`);
 		if (input === void 0) return current();
 		return current(input);
 	};
-	const createRpcNodeProxy = (segments) => {
+	const createRouteNodeProxy = (segments) => {
 		return new Proxy({}, { get: (_target, prop) => {
 			if (prop === "query") return (input) => queryOptions({
 				queryKey: buildKey(keyPrefix, [
-					"rpc",
+					"routes",
 					...segments,
 					"query",
 					locale,
 					normalizeQueryKeyOptions(input)
 				]),
-				queryFn: wrapQueryFn(() => callRpcProcedure(segments, input), errorMap)
+				queryFn: wrapQueryFn(() => callRoute(segments, input), errorMap)
 			});
 			if (prop === "mutation") return () => mutationOptions({
 				mutationKey: buildKey(keyPrefix, [
-					"rpc",
+					"routes",
 					...segments,
 					"mutation",
 					locale
 				]),
-				mutationFn: wrapMutationFn((variables) => callRpcProcedure(segments, variables), errorMap)
+				mutationFn: wrapMutationFn((variables) => callRoute(segments, variables), errorMap)
 			});
 			if (prop === "key") return (input) => buildKey(keyPrefix, [
-				"rpc",
+				"routes",
 				...segments,
 				"query",
 				locale,
 				normalizeQueryKeyOptions(input)
 			]);
 			if (typeof prop !== "string") return void 0;
-			return createRpcNodeProxy([...segments, prop]);
+			return createRouteNodeProxy([...segments, prop]);
 		} });
 	};
 	return {
 		collections,
 		globals,
-		rpc: new Proxy({}, { get: (_target, prop) => {
+		routes: new Proxy({}, { get: (_target, prop) => {
 			if (typeof prop !== "string") return void 0;
-			return createRpcNodeProxy([prop]);
+			return createRouteNodeProxy([prop]);
 		} }),
 		custom: {
 			query: (customConfig) => queryOptions({

package/package.json

@@ -1,39 +1,45 @@
 {
 	"name": "@questpie/tanstack-query",
-	"version": "2.0.0",
-	"type": "module",
+	"version": "3.0.1",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/questpie/questpie-cms.git",
+		"url": "https://github.com/questpie/questpie.git",
 		"directory": "packages/tanstack-query"
 	},
 	"files": [
 		"dist"
 	],
-	"scripts": {
-		"build": "tsdown",
-		"check-types": "tsc --noEmit"
-	},
-	"devDependencies": {
-		"bun-types": "latest",
-		"tsdown": "^0.18.3"
-	},
-	"peerDependencies": {
-		"questpie": "^2.0.0",
-		"@tanstack/react-query": "^5.0.0"
-	},
+	"type": "module",
+	"main": "./dist/index.mjs",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.mts",
 	"exports": {
-		".": "./dist/index.mjs",
+		".": {
+			"types": "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		},
 		"./package.json": "./package.json"
 	},
 	"publishConfig": {
 		"access": "public",
 		"exports": {
-			".": "./dist/index.mjs",
+			".": {
+				"types": "./dist/index.d.mts",
+				"default": "./dist/index.mjs"
+			},
 			"./package.json": "./package.json"
 		}
 	},
-	"main": "./dist/index.mjs",
-	"module": "./dist/index.mjs",
-	"types": "./dist/index.d.mts"
+	"scripts": {
+		"build": "tsdown",
+		"check-types": "tsc --noEmit"
+	},
+	"devDependencies": {
+		"bun-types": "latest",
+		"tsdown": "^0.18.3"
+	},
+	"peerDependencies": {
+		"@tanstack/react-query": "^5.0.0",
+		"questpie": "^3.0.0"
+	}
 }