@questpie/tanstack-query 1.1.1 → 2.0.0

package/README.md

@@ -1,12 +1,15 @@
 # @questpie/tanstack-query
 
-Type-safe TanStack React Query integration for QUESTPIE.
+Type-safe TanStack Query option builders for QUESTPIE — collections, globals, RPC procedures, and realtime streaming.
 
 ## Features
 
-- **Query Options Factory** - Pre-built query/mutation options using `queryOptions()` and `mutationOptions()` from TanStack Query
-- **SSR Ready** - Prefetch data on server, hydrate on client
-- **Type-Safe** - Full TypeScript inference from your CMS schema
+- **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
+- **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
 
 ## Installation
 
@@ -18,285 +21,221 @@ bun add @questpie/tanstack-query questpie @tanstack/react-query
 
 ### 1. Create Query Options
 
-```typescript
-// src/lib/queries.ts
+```ts
 import { createClient } from "questpie/client";
 import { createQuestpieQueryOptions } from "@questpie/tanstack-query";
-import type { AppCMS } from "@/cms";
+import type { AppCMS, AppRpc } from "@/questpie/server/cms";
 
-const cmsClient = createClient<AppCMS>({
+const cmsClient = createClient<AppCMS, AppRpc>({
   baseURL: "http://localhost:3000",
   basePath: "/api/cms",
 });
 
-export const q = createQuestpieQueryOptions(cmsClient, {
-  keyPrefix: ["cms"], // Optional: prefix for all query keys
-});
+export const cmsQueries = createQuestpieQueryOptions(cmsClient);
 ```
 
 ### 2. Use in Components
 
-```typescript
-import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query"
-import { q } from "@/lib/queries"
+```tsx
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { cmsQueries } from "@/lib/queries";
 
 function PostsList() {
-  // Queries
-  const { data: posts } = useQuery(q.collections.posts.find({ limit: 10 }))
-
-  // Mutations
-  const queryClient = useQueryClient()
+  const { data } = useQuery(
+    cmsQueries.collections.posts.find({ limit: 10 })
+  );
 
+  const queryClient = useQueryClient();
   const createPost = useMutation({
-    ...q.collections.posts.create(),
+    ...cmsQueries.collections.posts.create(),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["cms", "collections", "posts"] })
+      queryClient.invalidateQueries({ queryKey: cmsQueries.collections.posts.key() });
     },
-  })
+  });
 
   return (
     <div>
-      {posts?.docs.map((post) => (
-        <div key={post.id}>{post.title}</div>
-      ))}
+      {data?.docs.map((post) => <div key={post.id}>{post.title}</div>)}
       <button onClick={() => createPost.mutate({ title: "New Post" })}>
-        Create Post
+        Create
       </button>
     </div>
-  )
+  );
 }
 ```
 
-## Query Options API
+## Collections
 
-### Collections
-
-```typescript
-// Find many
-q.collections.posts.find({
+```ts
+// Find many (paginated)
+cmsQueries.collections.posts.find({
   where: { published: { eq: true } },
   orderBy: { createdAt: "desc" },
   limit: 10,
   offset: 0,
   with: { author: true },
-});
+})
 
 // Find one
-q.collections.posts.findOne({
+cmsQueries.collections.posts.findOne({
   where: { id: "post-id" },
-  with: { author: true, comments: true },
-});
+  with: { author: true },
+})
 
-// Create
-q.collections.posts.create();
-// Usage: mutation.mutate({ title: "...", content: "..." })
+// Count
+cmsQueries.collections.posts.count({
+  where: { published: { eq: true } },
+})
+
+// Create (mutation)
+cmsQueries.collections.posts.create()
+
+// Update (mutation)
+cmsQueries.collections.posts.update()
 
-// Update
-q.collections.posts.update();
-// Usage: mutation.mutate({ id: "...", data: { title: "..." } })
+// Delete (mutation)
+cmsQueries.collections.posts.delete()
 
-// Delete
-q.collections.posts.delete();
-// Usage: mutation.mutate({ id: "..." })
+// Update many (mutation)
+cmsQueries.collections.posts.updateMany()
 
-// Restore (soft delete)
-q.collections.posts.restore();
-// Usage: mutation.mutate({ id: "..." })
+// Delete many (mutation)
+cmsQueries.collections.posts.deleteMany()
+
+// Restore soft-deleted (mutation)
+cmsQueries.collections.posts.restore()
+
+// Query key for invalidation
+cmsQueries.collections.posts.key()
 ```
 
-### Globals
+## Globals
 
-```typescript
-// Get
-q.globals.siteSettings.get();
+```ts
+// Get global value
+cmsQueries.globals.siteSettings.get()
 
-// Update
-q.globals.siteSettings.update();
-// Usage: mutation.mutate({ data: { siteName: "..." } })
+// Update global (mutation)
+cmsQueries.globals.siteSettings.update()
+
+// Query key
+cmsQueries.globals.siteSettings.key()
 ```
 
-### Custom Queries
+## RPC
+
+Full type-safe query/mutation options for standalone RPC procedures:
 
-```typescript
-const searchQuery = q.custom.query({
-  key: ["search", query],
-  queryFn: () => fetch(`/api/search?q=${query}`).then((r) => r.json()),
+```ts
+// Query options from RPC procedure
+const { data } = useQuery(
+  cmsQueries.rpc.dashboard.getStats.query({ period: "week" })
+);
+
+// Mutation options from RPC procedure
+const publish = useMutation(
+  cmsQueries.rpc.posts.publish.mutation()
+);
+publish.mutate({ id: "post_123" });
+
+// Query key for invalidation/prefetch
+queryClient.invalidateQueries({
+  queryKey: cmsQueries.rpc.dashboard.getStats.key({ period: "week" }),
 });
+```
+
+## Realtime Streaming
+
+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 }
+  )
+);
+```
 
-useQuery(searchQuery);
+Topic helpers for manual subscription:
+
+```ts
+import { buildCollectionTopic, buildGlobalTopic } from "@questpie/tanstack-query";
+
+const postsTopic = buildCollectionTopic("posts");
+const settingsTopic = buildGlobalTopic("siteSettings");
 ```
 
 ## SSR Prefetching
 
 ### TanStack Start
 
-```typescript
-// src/routes/posts.tsx
-import { createFileRoute } from "@tanstack/react-router"
-import { useSuspenseQuery } from "@tanstack/react-query"
-import { q } from "@/lib/queries"
+```tsx
+import { createFileRoute } from "@tanstack/react-router";
+import { useSuspenseQuery } from "@tanstack/react-query";
+import { cmsQueries } from "@/lib/queries";
 
 export const Route = createFileRoute("/posts")({
   loader: async ({ context }) => {
     await context.queryClient.ensureQueryData(
-      q.collections.posts.find({ limit: 10 })
-    )
+      cmsQueries.collections.posts.find({ limit: 10 })
+    );
   },
   component: PostsPage,
-})
+});
 
 function PostsPage() {
-  const { data: posts } = useSuspenseQuery(
-    q.collections.posts.find({ limit: 10 })
-  )
-
+  const { data } = useSuspenseQuery(
+    cmsQueries.collections.posts.find({ limit: 10 })
+  );
   return (
     <ul>
-      {posts.docs.map((post) => (
-        <li key={post.id}>{post.title}</li>
-      ))}
+      {data.docs.map((post) => <li key={post.id}>{post.title}</li>)}
     </ul>
-  )
+  );
 }
 ```
 
 ### Next.js
 
-```typescript
-// app/posts/page.tsx
-import { HydrationBoundary, dehydrate } from "@tanstack/react-query"
-import { getQueryClient } from "@/lib/query-client"
-import { q } from "@/lib/queries"
-import { PostsList } from "./posts-list"
+```tsx
+import { HydrationBoundary, dehydrate } from "@tanstack/react-query";
+import { getQueryClient } from "@/lib/query-client";
+import { cmsQueries } from "@/lib/queries";
 
 export default async function PostsPage() {
-  const queryClient = getQueryClient()
-
+  const queryClient = getQueryClient();
   await queryClient.prefetchQuery(
-    q.collections.posts.find({ limit: 10 })
-  )
-
+    cmsQueries.collections.posts.find({ limit: 10 })
+  );
   return (
     <HydrationBoundary state={dehydrate(queryClient)}>
       <PostsList />
     </HydrationBoundary>
-  )
-}
-```
-
-## Optimistic Updates
-
-```typescript
-const queryClient = useQueryClient();
-
-const updatePost = useMutation({
-  ...q.collections.posts.update(),
-  onMutate: async ({ id, data }) => {
-    await queryClient.cancelQueries({
-      queryKey: ["cms", "collections", "posts"],
-    });
-
-    const previousPosts = queryClient.getQueryData([
-      "cms",
-      "collections",
-      "posts",
-    ]);
-
-    queryClient.setQueryData(["cms", "collections", "posts"], (old) => ({
-      ...old,
-      docs: old.docs.map((post) =>
-        post.id === id ? { ...post, ...data } : post,
-      ),
-    }));
-
-    return { previousPosts };
-  },
-  onError: (err, variables, context) => {
-    queryClient.setQueryData(
-      ["cms", "collections", "posts"],
-      context?.previousPosts,
-    );
-  },
-  onSettled: () => {
-    queryClient.invalidateQueries({
-      queryKey: ["cms", "collections", "posts"],
-    });
-  },
-});
-```
-
-## Infinite Queries
-
-```typescript
-import { useInfiniteQuery } from "@tanstack/react-query"
-import { cmsClient } from "@/lib/cms-client"
-
-function InfinitePosts() {
-  const { data, fetchNextPage, hasNextPage } = useInfiniteQuery({
-    queryKey: ["cms", "collections", "posts", "infinite"],
-    queryFn: ({ pageParam = 0 }) =>
-      cmsClient.collections.posts.find({
-        limit: 10,
-        offset: pageParam,
-      }),
-    getNextPageParam: (lastPage, allPages) => {
-      const totalFetched = allPages.flatMap((p) => p.docs).length
-      return lastPage.docs.length === 10 ? totalFetched : undefined
-    },
-    initialPageParam: 0,
-  })
-
-  return (
-    <div>
-      {data?.pages.flatMap((page) =>
-        page.docs.map((post) => <div key={post.id}>{post.title}</div>)
-      )}
-      {hasNextPage && (
-        <button onClick={() => fetchNextPage()}>Load More</button>
-      )}
-    </div>
-  )
+  );
 }
 ```
 
 ## Query Key Structure
 
-All query keys follow this structure:
-
-```typescript
+```ts
 // Collections
-[...keyPrefix, "collections", collectionName, "find", options]
-[...keyPrefix, "collections", collectionName, "findOne", options]
+["collections", collectionName, "find", options]
+["collections", collectionName, "findOne", options]
+["collections", collectionName, "count", options]
 
 // Globals
-[...keyPrefix, "globals", globalName, "get", options]
-
-// Custom
-[...keyPrefix, ...customKey]
-```
-
-## TypeScript
-
-Full type inference from your CMS schema:
-
-```typescript
-import type { CollectionSelect } from "questpie";
-import type { AppCMS } from "@/cms";
-
-// Collection item type
-type Post = CollectionSelect<AppCMS["config"]["collections"]["posts"]>;
+["globals", globalName, "get"]
 
-// Query result types are automatically inferred
-const { data } = useQuery(q.collections.posts.find({ limit: 10 }));
-//    ^? { docs: Post[], totalDocs: number, ... }
+// RPC
+["rpc", ...segments, "query", input]
+["rpc", ...segments, "mutation"]
 ```
 
-## Related Packages
+## Documentation
 
-- [`questpie`](../questpie) - Core CMS engine
-- [`@questpie/hono`](../hono) - Hono adapter
-- [`@questpie/elysia`](../elysia) - Elysia adapter
-- [`@questpie/next`](../next) - Next.js adapter
+Full documentation: [https://questpie.com/docs/client/tanstack-query](https://questpie.com/docs/client/tanstack-query)
 
 ## License
 

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { DefaultError, QueryKey, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
+import { QuestpieClient, RealtimeAPI, TopicConfig, buildCollectionTopic, buildGlobalTopic } from "questpie/client";
 import { Questpie } from "questpie";
-import { QuestpieClient } from "questpie/client";
 
 //#region src/index.d.ts
 type QuestpieQueryErrorMap = (error: unknown) => unknown;
@@ -14,50 +14,62 @@ type QueryData<TFn extends AnyAsyncFn> = Awaited<ReturnType<TFn>>;
 type FirstArg<TFn extends AnyAsyncFn> = Parameters<TFn> extends [infer TFirst, ...any[]] ? TFirst : never;
 type HasArgs<TFn extends AnyAsyncFn> = Parameters<TFn> extends [] ? false : true;
 type QueryBuilder<TFn extends AnyAsyncFn> = HasArgs<TFn> extends false ? () => UseQueryOptions<QueryData<TFn>> : undefined extends FirstArg<TFn> ? (options?: FirstArg<TFn>) => UseQueryOptions<QueryData<TFn>> : (options: FirstArg<TFn>) => UseQueryOptions<QueryData<TFn>>;
+type KeyBuilder<TFn extends AnyAsyncFn> = HasArgs<TFn> extends false ? () => QueryKey : undefined extends FirstArg<TFn> ? (options?: FirstArg<TFn>) => QueryKey : (options: FirstArg<TFn>) => QueryKey;
+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<T extends Questpie<any>> = Extract<keyof QuestpieClient<T>["collections"], string>;
+type CollectionKeys<TCMS extends Questpie<any>, TRPC extends Record<string, any>> = Extract<keyof QuestpieClient<TCMS, TRPC>["collections"], string>;
 /** Extract global keys from QuestpieClient */
-type GlobalKeys<T extends Questpie<any>> = Extract<keyof QuestpieClient<T>["globals"], string>;
-type CollectionFind<T extends Questpie<any>, K$1 extends CollectionKeys<T>> = QuestpieClient<T>["collections"][K$1]["find"];
-type CollectionCount<T extends Questpie<any>, K$1 extends CollectionKeys<T>> = QuestpieClient<T>["collections"][K$1]["count"];
-type CollectionFindOne<T extends Questpie<any>, K$1 extends CollectionKeys<T>> = QuestpieClient<T>["collections"][K$1]["findOne"];
-type CollectionCreate<T extends Questpie<any>, K$1 extends CollectionKeys<T>> = QuestpieClient<T>["collections"][K$1]["create"];
-type CollectionUpdate<T extends Questpie<any>, K$1 extends CollectionKeys<T>> = QuestpieClient<T>["collections"][K$1]["update"];
-type CollectionDelete<T extends Questpie<any>, K$1 extends CollectionKeys<T>> = QuestpieClient<T>["collections"][K$1]["delete"];
-type CollectionRestore<T extends Questpie<any>, K$1 extends CollectionKeys<T>> = QuestpieClient<T>["collections"][K$1]["restore"];
-type GlobalGet<T extends Questpie<any>, K$1 extends GlobalKeys<T>> = QuestpieClient<T>["globals"][K$1] extends {
+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 {
   get: infer TGet;
 } ? TGet extends AnyAsyncFn ? TGet : never : never;
-type GlobalUpdate<T extends Questpie<any>, K$1 extends GlobalKeys<T>> = QuestpieClient<T>["globals"][K$1] extends {
+type GlobalUpdate<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends GlobalKeys<TCMS, TRPC>> = QuestpieClient<TCMS, TRPC>["globals"][K$1] extends {
   update: infer TUpdate;
 } ? TUpdate extends AnyAsyncFn ? TUpdate : never : never;
-type CollectionQueryOptionsAPI<T extends Questpie<any>, K$1 extends CollectionKeys<T>> = {
-  find: QueryBuilder<CollectionFind<T, K$1>>;
-  count: QueryBuilder<CollectionCount<T, K$1>>;
-  findOne: QueryBuilder<CollectionFindOne<T, K$1>>;
-  create: MutationBuilder<FirstArg<CollectionCreate<T, K$1>>, QueryData<CollectionCreate<T, K$1>>>;
-  update: MutationBuilder<{
-    id: Parameters<CollectionUpdate<T, K$1>>[0];
-    data: Parameters<CollectionUpdate<T, K$1>>[1];
-  }, QueryData<CollectionUpdate<T, K$1>>>;
-  delete: MutationBuilder<{
-    id: Parameters<CollectionDelete<T, K$1>>[0];
-  }, QueryData<CollectionDelete<T, K$1>>>;
-  restore: MutationBuilder<{
-    id: Parameters<CollectionRestore<T, K$1>>[0];
-  }, QueryData<CollectionRestore<T, K$1>>>;
+type RpcProcedureQueryOptionsAPI<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>>>;
+  updateMany: MutationBuilder<{
+    where: any;
+    data: any;
+  }, QueryData<CollectionUpdate<TCMS, TRPC, K$1>>>;
+  deleteMany: MutationBuilder<{
+    where: any;
+  }, {
+    success: boolean;
+    count: number;
+  }>;
 };
-type GlobalQueryOptionsAPI<T extends Questpie<any>, K$1 extends GlobalKeys<T>> = {
-  get: QueryBuilder<GlobalGet<T, K$1>>;
+type GlobalQueryOptionsAPI<TCMS extends Questpie<any>, TRPC extends Record<string, any>, K$1 extends GlobalKeys<TCMS, TRPC>> = {
+  get: QueryBuilder<GlobalGet<TCMS, TRPC, K$1>>;
   update: MutationBuilder<{
-    data: Parameters<GlobalUpdate<T, K$1>>[0];
-    options?: Parameters<GlobalUpdate<T, K$1>>[1];
-  }, QueryData<GlobalUpdate<T, K$1>>>;
+    data: Parameters<GlobalUpdate<TCMS, TRPC, K$1>>[0];
+    options?: Parameters<GlobalUpdate<TCMS, TRPC, K$1>>[1];
+  }, QueryData<GlobalUpdate<TCMS, TRPC, K$1>>>;
 };
-type QuestpieQueryOptionsProxy<T extends Questpie<any>> = {
-  collections: { [K in CollectionKeys<T>]: CollectionQueryOptionsAPI<T, K> };
-  globals: { [K in GlobalKeys<T>]: GlobalQueryOptionsAPI<T, K> };
+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"]>;
   custom: {
     query: <TData>(config: {
       key: QueryKey;
@@ -77,17 +89,21 @@ type QuestpieQueryOptionsProxy<T extends Questpie<any>> = {
  * ```ts
  * import { createQuestpieQueryOptions } from "@questpie/tanstack-query"
  * import { createClient } from "questpie/client"
+ * import type { AppCMS, AppRpc } from "@/cms"
  *
- * const client = createClient<typeof cms>({ baseURL: "http://localhost:3000" })
- * const qpo = createQuestpieQueryOptions(client)
+ * const client = createClient<AppCMS, AppRpc>({ baseURL: "http://localhost:3000" })
+ * const cmsQueries = createQuestpieQueryOptions(client)
  *
  * // Use with useQuery
- * const { data } = useQuery(qpo.collections.posts.find({ limit: 10 }))
+ * const { data } = useQuery(cmsQueries.collections.posts.find({ limit: 10 }))
  *
  * // Use with useMutation
- * const mutation = useMutation(qpo.collections.posts.create())
+ * const mutation = useMutation(cmsQueries.collections.posts.create())
+ *
+ * // Use with RPC
+ * const stats = useQuery(cmsQueries.rpc.dashboard.getStats.query({ period: "week" }))
  * ```
  */
-declare function createQuestpieQueryOptions<T extends Questpie<any>>(client: QuestpieClient<T>, config?: QuestpieQueryOptionsConfig): QuestpieQueryOptionsProxy<T>;
+declare function createQuestpieQueryOptions<TCMS extends Questpie<any>, TRPC extends Record<string, any> = Record<string, never>>(client: QuestpieClient<TCMS, TRPC>, config?: QuestpieQueryOptionsConfig): QuestpieQueryOptionsProxy<TCMS, TRPC>;
 //#endregion
-export { type DefaultError, type QueryKey, QuestpieQueryErrorMap, QuestpieQueryOptionsConfig, QuestpieQueryOptionsProxy, type UseMutationOptions, type UseQueryOptions, createQuestpieQueryOptions };
+export { type DefaultError, type QueryKey, QuestpieQueryErrorMap, QuestpieQueryOptionsConfig, QuestpieQueryOptionsProxy, type RealtimeAPI, type TopicConfig, type UseMutationOptions, type UseQueryOptions, buildCollectionTopic, buildGlobalTopic, createQuestpieQueryOptions };

package/dist/index.mjs

@@ -1,4 +1,5 @@
-import { mutationOptions, queryOptions } from "@tanstack/react-query";
+import { experimental_streamedQuery, mutationOptions, queryOptions } from "@tanstack/react-query";
+import { buildCollectionTopic, buildCollectionTopic as buildCollectionTopic$1, buildGlobalTopic, buildGlobalTopic as buildGlobalTopic$1 } from "questpie/client";
 
 //#region src/index.ts
 const defaultErrorMap = (error) => error instanceof Error ? error : new Error(typeof error === "string" ? error : "Unknown error");
@@ -44,114 +45,224 @@ const wrapMutationFn = (mutationFn, errorMap) => {
 * ```ts
 * import { createQuestpieQueryOptions } from "@questpie/tanstack-query"
 * import { createClient } from "questpie/client"
+* import type { AppCMS, AppRpc } from "@/cms"
 *
-* const client = createClient<typeof cms>({ baseURL: "http://localhost:3000" })
-* const qpo = createQuestpieQueryOptions(client)
+* const client = createClient<AppCMS, AppRpc>({ baseURL: "http://localhost:3000" })
+* const cmsQueries = createQuestpieQueryOptions(client)
 *
 * // Use with useQuery
-* const { data } = useQuery(qpo.collections.posts.find({ limit: 10 }))
+* const { data } = useQuery(cmsQueries.collections.posts.find({ limit: 10 }))
 *
 * // Use with useMutation
-* const mutation = useMutation(qpo.collections.posts.create())
+* const mutation = useMutation(cmsQueries.collections.posts.create())
+*
+* // Use with RPC
+* const stats = useQuery(cmsQueries.rpc.dashboard.getStats.query({ period: "week" }))
 * ```
 */
 function createQuestpieQueryOptions(client, config = {}) {
 	const keyPrefix = config.keyPrefix ?? ["questpie"];
 	const errorMap = config.errorMap ?? defaultErrorMap;
 	const locale = config.locale;
-	return {
-		collections: new Proxy({}, { get: (_target, collectionName) => {
-			if (typeof collectionName !== "string") return void 0;
-			const collection = client.collections[collectionName];
-			const baseKey = ["collections", collectionName];
-			return {
-				find: (options) => queryOptions({
-					queryKey: buildKey(keyPrefix, [
-						...baseKey,
-						"find",
-						locale,
-						normalizeQueryKeyOptions(options)
-					]),
+	const collections = new Proxy({}, { get: (_target, collectionName) => {
+		if (typeof collectionName !== "string") return void 0;
+		const collection = client.collections[collectionName];
+		const baseKey = ["collections", collectionName];
+		return {
+			find: (options, queryConfig) => {
+				const qKey = buildKey(keyPrefix, [
+					...baseKey,
+					"find",
+					locale,
+					normalizeQueryKeyOptions(options)
+				]);
+				if (queryConfig?.realtime && client.realtime) {
+					const topic = buildCollectionTopic$1(collectionName, options);
+					return queryOptions({
+						queryKey: qKey,
+						queryFn: experimental_streamedQuery({
+							streamFn: ({ signal }) => client.realtime.stream(topic, signal),
+							reducer: (_, chunk) => chunk,
+							initialValue: void 0,
+							refetchMode: "append"
+						})
+					});
+				}
+				return queryOptions({
+					queryKey: qKey,
 					queryFn: wrapQueryFn(() => collection.find(options), errorMap)
-				}),
-				count: (options) => queryOptions({
-					queryKey: buildKey(keyPrefix, [
-						...baseKey,
-						"count",
-						locale,
-						normalizeQueryKeyOptions(options)
-					]),
+				});
+			},
+			count: (options, queryConfig) => {
+				const qKey = buildKey(keyPrefix, [
+					...baseKey,
+					"count",
+					locale,
+					normalizeQueryKeyOptions(options)
+				]);
+				if (queryConfig?.realtime && client.realtime) {
+					const topic = buildCollectionTopic$1(collectionName, options);
+					return queryOptions({
+						queryKey: qKey,
+						queryFn: experimental_streamedQuery({
+							streamFn: ({ signal }) => client.realtime.stream(topic, signal),
+							reducer: (_, chunk) => typeof chunk?.totalDocs === "number" ? chunk.totalDocs : chunk,
+							initialValue: void 0,
+							refetchMode: "append"
+						})
+					});
+				}
+				return queryOptions({
+					queryKey: qKey,
 					queryFn: wrapQueryFn(() => collection.count(options), errorMap)
-				}),
-				findOne: (options) => queryOptions({
-					queryKey: buildKey(keyPrefix, [
-						...baseKey,
-						"findOne",
-						locale,
-						normalizeQueryKeyOptions(options)
-					]),
-					queryFn: wrapQueryFn(() => collection.findOne(options), errorMap)
-				}),
-				create: () => mutationOptions({
-					mutationKey: buildKey(keyPrefix, [
-						...baseKey,
-						"create",
-						locale
-					]),
-					mutationFn: wrapMutationFn((data) => collection.create(data, locale ? { locale } : void 0), errorMap)
-				}),
-				update: () => mutationOptions({
-					mutationKey: buildKey(keyPrefix, [
-						...baseKey,
-						"update",
-						locale
-					]),
-					mutationFn: wrapMutationFn((variables) => collection.update(variables.id, variables.data, locale ? { locale } : void 0), errorMap)
-				}),
-				delete: () => mutationOptions({
-					mutationKey: buildKey(keyPrefix, [
-						...baseKey,
-						"delete",
-						locale
-					]),
-					mutationFn: wrapMutationFn((variables) => collection.delete(variables.id, locale ? { locale } : void 0), errorMap)
-				}),
-				restore: () => mutationOptions({
-					mutationKey: buildKey(keyPrefix, [
-						...baseKey,
-						"restore",
-						locale
-					]),
-					mutationFn: wrapMutationFn((variables) => collection.restore(variables.id, locale ? { locale } : void 0), errorMap)
-				})
-			};
-		} }),
-		globals: new Proxy({}, { get: (_target, globalName) => {
-			if (typeof globalName !== "string") return void 0;
-			const global = client.globals[globalName];
-			const baseKey = ["globals", globalName];
-			return {
-				get: (options) => queryOptions({
-					queryKey: buildKey(keyPrefix, [
-						...baseKey,
-						"get",
-						locale,
-						normalizeQueryKeyOptions(options)
-					]),
+				});
+			},
+			findOne: (options) => queryOptions({
+				queryKey: buildKey(keyPrefix, [
+					...baseKey,
+					"findOne",
+					locale,
+					normalizeQueryKeyOptions(options)
+				]),
+				queryFn: wrapQueryFn(() => collection.findOne(options), errorMap)
+			}),
+			create: () => mutationOptions({
+				mutationKey: buildKey(keyPrefix, [
+					...baseKey,
+					"create",
+					locale
+				]),
+				mutationFn: wrapMutationFn((data) => collection.create(data, locale ? { locale } : void 0), errorMap)
+			}),
+			update: () => mutationOptions({
+				mutationKey: buildKey(keyPrefix, [
+					...baseKey,
+					"update",
+					locale
+				]),
+				mutationFn: wrapMutationFn((variables) => collection.update(variables, locale ? { locale } : void 0), errorMap)
+			}),
+			delete: () => mutationOptions({
+				mutationKey: buildKey(keyPrefix, [
+					...baseKey,
+					"delete",
+					locale
+				]),
+				mutationFn: wrapMutationFn((variables) => collection.delete(variables, locale ? { locale } : void 0), errorMap)
+			}),
+			restore: () => mutationOptions({
+				mutationKey: buildKey(keyPrefix, [
+					...baseKey,
+					"restore",
+					locale
+				]),
+				mutationFn: wrapMutationFn((variables) => collection.restore(variables, locale ? { locale } : void 0), errorMap)
+			}),
+			updateMany: () => mutationOptions({
+				mutationKey: buildKey(keyPrefix, [
+					...baseKey,
+					"updateMany",
+					locale
+				]),
+				mutationFn: wrapMutationFn((variables) => collection.updateMany(variables, locale ? { locale } : void 0), errorMap)
+			}),
+			deleteMany: () => mutationOptions({
+				mutationKey: buildKey(keyPrefix, [
+					...baseKey,
+					"deleteMany",
+					locale
+				]),
+				mutationFn: wrapMutationFn((variables) => collection.deleteMany(variables, locale ? { locale } : void 0), errorMap)
+			})
+		};
+	} });
+	const globals = new Proxy({}, { get: (_target, globalName) => {
+		if (typeof globalName !== "string") return void 0;
+		const global = client.globals[globalName];
+		const baseKey = ["globals", globalName];
+		return {
+			get: (options, queryConfig) => {
+				const qKey = buildKey(keyPrefix, [
+					...baseKey,
+					"get",
+					locale,
+					normalizeQueryKeyOptions(options)
+				]);
+				if (queryConfig?.realtime && client.realtime) {
+					const topic = buildGlobalTopic$1(globalName, options);
+					return queryOptions({
+						queryKey: qKey,
+						queryFn: experimental_streamedQuery({
+							streamFn: ({ signal }) => client.realtime.stream(topic, signal),
+							reducer: (_, chunk) => chunk,
+							initialValue: void 0,
+							refetchMode: "append"
+						})
+					});
+				}
+				return queryOptions({
+					queryKey: qKey,
 					queryFn: wrapQueryFn(() => global.get(options), errorMap)
-				}),
-				update: () => mutationOptions({
-					mutationKey: buildKey(keyPrefix, [
-						...baseKey,
-						"update",
-						locale
-					]),
-					mutationFn: wrapMutationFn((variables) => global.update(variables.data, {
-						...variables.options,
-						...locale ? { locale } : void 0
-					}), errorMap)
-				})
-			};
+				});
+			},
+			update: () => mutationOptions({
+				mutationKey: buildKey(keyPrefix, [
+					...baseKey,
+					"update",
+					locale
+				]),
+				mutationFn: wrapMutationFn((variables) => global.update(variables.data, {
+					...variables.options,
+					...locale ? { locale } : void 0
+				}), errorMap)
+			})
+		};
+	} });
+	const callRpcProcedure = async (segments, input) => {
+		let current = client.rpc;
+		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 (input === void 0) return current();
+		return current(input);
+	};
+	const createRpcNodeProxy = (segments) => {
+		return new Proxy({}, { get: (_target, prop) => {
+			if (prop === "query") return (input) => queryOptions({
+				queryKey: buildKey(keyPrefix, [
+					"rpc",
+					...segments,
+					"query",
+					locale,
+					normalizeQueryKeyOptions(input)
+				]),
+				queryFn: wrapQueryFn(() => callRpcProcedure(segments, input), errorMap)
+			});
+			if (prop === "mutation") return () => mutationOptions({
+				mutationKey: buildKey(keyPrefix, [
+					"rpc",
+					...segments,
+					"mutation",
+					locale
+				]),
+				mutationFn: wrapMutationFn((variables) => callRpcProcedure(segments, variables), errorMap)
+			});
+			if (prop === "key") return (input) => buildKey(keyPrefix, [
+				"rpc",
+				...segments,
+				"query",
+				locale,
+				normalizeQueryKeyOptions(input)
+			]);
+			if (typeof prop !== "string") return void 0;
+			return createRpcNodeProxy([...segments, prop]);
+		} });
+	};
+	return {
+		collections,
+		globals,
+		rpc: new Proxy({}, { get: (_target, prop) => {
+			if (typeof prop !== "string") return void 0;
+			return createRpcNodeProxy([prop]);
 		} }),
 		custom: {
 			query: (customConfig) => queryOptions({
@@ -168,4 +279,4 @@ function createQuestpieQueryOptions(client, config = {}) {
 }
 
 //#endregion
-export { createQuestpieQueryOptions };
+export { buildCollectionTopic, buildGlobalTopic, createQuestpieQueryOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@questpie/tanstack-query",
-	"version": "1.1.1",
+	"version": "2.0.0",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -19,16 +19,21 @@
 		"tsdown": "^0.18.3"
 	},
 	"peerDependencies": {
-		"questpie": "^1.0.0",
+		"questpie": "^2.0.0",
 		"@tanstack/react-query": "^5.0.0"
 	},
 	"exports": {
-		".": {
-			"import": "./dist/index.mjs",
-			"types": "./dist/index.d.mts"
-		}
+		".": "./dist/index.mjs",
+		"./package.json": "./package.json"
 	},
 	"publishConfig": {
-		"access": "public"
-	}
+		"access": "public",
+		"exports": {
+			".": "./dist/index.mjs",
+			"./package.json": "./package.json"
+		}
+	},
+	"main": "./dist/index.mjs",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.mts"
 }