@orpc/vue-query 0.0.0-next.ff5907c → 0.0.0-next.ff7ad2e

package/README.md

@@ -0,0 +1,120 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/vue-query">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fvue-query?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards
+
+---
+
+## Highlights
+
+- **🔗 End-to-End Type Safety**: Ensure type-safe inputs, outputs, and errors from client to server.
+- **📘 First-Class OpenAPI**: Built-in support that fully adheres to the OpenAPI standard.
+- **📝 Contract-First Development**: Optionally define your API contract before implementation.
+- **🔍 First-Class OpenTelemetry**: Seamlessly integrate with OpenTelemetry for observability.
+- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte, Angular), SWR, Pinia Colada, and more.
+- **🚀 Server Actions**: Fully compatible with React Server Actions on Next.js, TanStack Start, and other platforms.
+- **🔠 Standard Schema Support**: Works out of the box with Zod, Valibot, ArkType, and other schema validators.
+- **🗃️ Native Types**: Supports native types like Date, File, Blob, BigInt, URL, and more.
+- **⏱️ Lazy Router**: Enhance cold start times with our lazy routing feature.
+- **📡 SSE & Streaming**: Enjoy full type-safe support for SSE and streaming.
+- **🌍 Multi-Runtime Support**: Fast and lightweight on Cloudflare, Deno, Bun, Node.js, and beyond.
+- **🔌 Extendability**: Easily extend functionality with plugins, middleware, and interceptors.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
+- [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
+- [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/otel](https://www.npmjs.com/package/@orpc/otel): [OpenTelemetry](https://opentelemetry.io/) integration for observability.
+- [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with [NestJS](https://nestjs.com/).
+- [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
+- [@orpc/tanstack-query](https://www.npmjs.com/package/@orpc/tanstack-query): [TanStack Query](https://tanstack.com/query/latest) integration.
+- [@orpc/experimental-react-swr](https://www.npmjs.com/package/@orpc/experimental-react-swr): [SWR](https://swr.vercel.app/) integration.
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/hey-api](https://www.npmjs.com/package/@orpc/hey-api): [Hey API](https://heyapi.dev/) integration.
+- [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+- [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot): OpenAPI spec generation from [Valibot](https://valibot.dev/).
+- [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype): OpenAPI spec generation from [ArkType](https://arktype.io/).
+
+## `@orpc/vue-query`
+
+Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview). Read the [documentation](https://orpc.unnoq.com/docs/integrations/tanstack-query-old/vue) for more information.
+
+```ts
+export function Setup() {
+  const query = useQuery(orpc.planet.find.queryOptions({
+    input: { id: 123 }, // Specify input if needed
+    context: { cache: true }, // Provide client context if needed
+  // additional options...
+  }))
+
+  const query = useInfiniteQuery(orpc.planet.list.infiniteOptions({
+    input: (pageParam: number | undefined) => ({ limit: 10, offset: pageParam }),
+    context: { cache: true }, // Provide client context if needed
+    initialPageParam: undefined,
+    getNextPageParam: lastPage => lastPage.nextPageParam,
+  // additional options...
+  }))
+
+  const mutation = useMutation(orpc.planet.create.mutationOptions({
+    context: { cache: true }, // Provide client context if needed
+  // additional options...
+  }))
+
+  mutation.mutate({ name: 'Earth' })
+
+  const queryClient = useQueryClient()
+
+  // Invalidate all planet queries
+  queryClient.invalidateQueries({
+    queryKey: orpc.planet.key(),
+  })
+
+  // Invalidate only regular (non-infinite) planet queries
+  queryClient.invalidateQueries({
+    queryKey: orpc.planet.key({ type: 'query' })
+  })
+
+  // Invalidate the planet find query with id 123
+  queryClient.invalidateQueries({
+    queryKey: orpc.planet.find.key({ input: { id: 123 } })
+  })
+}
+```
+
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg'/>
+  </a>
+</p>
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/index.d.mts

@@ -0,0 +1,142 @@
+import { ClientContext, Client, NestedClient } from '@orpc/client';
+import { OperationType, OperationKeyOptions } from '@orpc/tanstack-query';
+export { OperationKeyOptions as BuildKeyOptions, OperationType as KeyType, generateOperationKey as buildKey } from '@orpc/tanstack-query';
+import { QueryKey, SkipToken, QueryObserverOptions, QueryFunctionContext, experimental_streamedQuery, InfiniteQueryObserverOptions, MutationObserverOptions, InfiniteData } from '@tanstack/vue-query';
+import { AnyFunction, MaybeOptionalOptions } from '@orpc/shared';
+import { MaybeRef, MaybeRefOrGetter, ComputedRef, Ref } from 'vue';
+
+interface GeneralUtils<TInput> {
+    /**
+     * Generate a query/mutation key for checking status, invalidate, set, get, etc.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/basic#query-mutation-key Tanstack Query/Mutation Key Docs}
+     */
+    key<UType extends OperationType>(options?: OperationKeyOptions<UType, TInput>): QueryKey;
+}
+declare function createGeneralUtils<TInput>(path: string[]): GeneralUtils<TInput>;
+
+/**
+ * Since `@tanstack/vue-query` is not exporting the type `MaybeRefDeep` we need to copy it from the source code.
+ * https://github.com/TanStack/query/blob/7ff544e12e79388e513b1cd886aeb946f80f0153/packages/vue-query/src/types.ts#L19C1-L27C2
+ */
+type MaybeRefDeep<T> = MaybeRef<T extends AnyFunction ? T : T extends object ? {
+    [Property in keyof T]: MaybeRefDeep<T[Property]>;
+} : T>;
+type QueryOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TSelectData> = (undefined extends TInput ? {
+    input?: MaybeRefDeep<TInput | SkipToken>;
+} : {
+    input: MaybeRefDeep<TInput | SkipToken>;
+}) & (Record<never, never> extends TClientContext ? {
+    context?: MaybeRefDeep<TClientContext>;
+} : {
+    context: MaybeRefDeep<TClientContext>;
+}) & {
+    [P in keyof Omit<QueryObserverOptions<TOutput, TError, TSelectData, TOutput>, 'queryKey' | 'enabled'>]: MaybeRefDeep<QueryObserverOptions<TOutput, TError, TSelectData, TOutput>[P]>;
+} & {
+    enabled?: MaybeRefOrGetter<QueryObserverOptions<TOutput, TError, TSelectData, TOutput>['enabled']>;
+    queryKey?: MaybeRefDeep<QueryObserverOptions<TOutput, TError, TSelectData, TOutput>['queryKey']>;
+    shallow?: boolean;
+};
+interface QueryOptionsBase<TOutput, TError> {
+    queryKey: ComputedRef<QueryKey>;
+    queryFn(ctx: QueryFunctionContext): Promise<TOutput>;
+    throwOnError?(error: TError): boolean;
+    retryDelay?: (count: number, error: TError) => number;
+    enabled: ComputedRef<boolean | undefined>;
+}
+type experimental_StreamedQueryOptions = Omit<Parameters<typeof experimental_streamedQuery>[0], 'queryFn'>;
+type experimental_InferStreamedOutput<TOutput> = TOutput extends AsyncIterable<infer U> ? U[] : never;
+type experimental_StreamedOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TSelectData> = QueryOptionsIn<TClientContext, TInput, TOutput, TError, TSelectData> & {
+    queryFnOptions?: experimental_StreamedQueryOptions;
+};
+interface experimental_StreamedOptionsBase<TOutput, TError> extends QueryOptionsBase<TOutput, TError> {
+}
+type InfiniteOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TSelectData, TPageParam> = (Record<never, never> extends TClientContext ? {
+    context?: MaybeRefDeep<TClientContext>;
+} : {
+    context: MaybeRefDeep<TClientContext>;
+}) & {
+    [Property in keyof Omit<InfiniteQueryObserverOptions<TOutput, TError, TSelectData, QueryKey, TPageParam>, 'queryKey' | 'enabled'>]: MaybeRefDeep<InfiniteQueryObserverOptions<TOutput, TError, TSelectData, QueryKey, TPageParam>[Property]>;
+} & {
+    input: MaybeRef<((pageParam: TPageParam) => MaybeRefDeep<TInput>) | SkipToken>;
+    enabled?: MaybeRefOrGetter<InfiniteQueryObserverOptions<TOutput, TError, TSelectData, QueryKey, TPageParam>['enabled']>;
+    queryKey?: MaybeRefDeep<InfiniteQueryObserverOptions<TOutput, TError, TSelectData, QueryKey, TPageParam>['queryKey']>;
+    shallow?: boolean;
+};
+interface InfiniteOptionsBase<TOutput, TError, TPageParam> {
+    queryKey: ComputedRef<QueryKey>;
+    queryFn(ctx: QueryFunctionContext<QueryKey, TPageParam>): Promise<TOutput>;
+    throwOnError?(error: TError): boolean;
+    retryDelay?: (count: number, error: TError) => number;
+    enabled: ComputedRef<boolean | undefined>;
+}
+type MutationOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TMutationContext> = (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+}) & MutationOptions<TInput, TOutput, TError, TMutationContext>;
+type MutationOptions<TInput, TOutput, TError, TMutationContext> = {
+    [P in keyof MutationObserverOptions<TOutput, TError, TInput, TMutationContext>]: MaybeRefDeep<MutationObserverOptions<TOutput, TError, TInput, TMutationContext>[P]>;
+} & {
+    shallow?: MaybeRef<boolean>;
+};
+
+interface ProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError> {
+    /**
+     * Calling corresponding procedure client
+     *
+     * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/basic#calling-procedure-clients Tanstack Calling Procedure Client Docs}
+     */
+    call: Client<TClientContext, TInput, TOutput, TError>;
+    /**
+     * Generate options used for useQuery/prefetchQuery/...
+     *
+     * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/basic#query-options-utility Tanstack Query Options Utility Docs}
+     */
+    queryOptions<U, USelectData = TOutput>(...rest: MaybeOptionalOptions<U & QueryOptionsIn<TClientContext, TInput, TOutput, TError, USelectData>>): NoInfer<U & Omit<QueryOptionsBase<TOutput, TError>, keyof U>>;
+    /**
+     * Generate [Event Iterator](https://orpc.unnoq.com/docs/event-iterator) options used for useQuery/prefetchQuery/...
+     * Built on top of [steamedQuery](https://tanstack.com/query/latest/docs/reference/streamedQuery)
+     *
+     * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/basic#streamed-query-options-utility Tanstack Streamed Query Options Utility Docs}
+     */
+    experimental_streamedOptions<U, USelectData = experimental_InferStreamedOutput<TOutput>>(...rest: MaybeOptionalOptions<U & experimental_StreamedOptionsIn<TClientContext, TInput, experimental_InferStreamedOutput<TOutput>, TError, USelectData>>): NoInfer<U & Omit<experimental_StreamedOptionsBase<experimental_InferStreamedOutput<TOutput>, TError>, keyof U>>;
+    /**
+     * Generate options used for useInfiniteQuery/prefetchInfiniteQuery/...
+     *
+     * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/basic#infinite-query-options-utility Tanstack Infinite Query Options Utility Docs}
+     */
+    infiniteOptions<U, UPageParam, USelectData = InfiniteData<TOutput, UPageParam>>(options: U & InfiniteOptionsIn<TClientContext, TInput, TOutput, TError, USelectData, UPageParam>): NoInfer<U & Omit<InfiniteOptionsBase<TOutput, TError, UPageParam>, keyof U>>;
+    /**
+     * Generate options used for useMutation/...
+     *
+     * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/basic#mutation-options Tanstack Mutation Options Docs}
+     */
+    mutationOptions<UMutationContext>(...rest: MaybeOptionalOptions<MutationOptionsIn<TClientContext, TInput, TOutput, TError, UMutationContext>>): MutationOptions<TInput, TOutput, TError, UMutationContext>;
+}
+interface CreateProcedureUtilsOptions {
+    path: string[];
+}
+declare function createProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError>(client: Client<TClientContext, TInput, TOutput, TError>, options: CreateProcedureUtilsOptions): ProcedureUtils<TClientContext, TInput, TOutput, TError>;
+
+type RouterUtils<T extends NestedClient<any>> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? ProcedureUtils<UClientContext, UInput, UOutput, UError> & GeneralUtils<UInput> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? RouterUtils<T[K]> : never;
+} & GeneralUtils<unknown>;
+interface CreateRouterUtilsOptions {
+    path?: string[];
+}
+/**
+ * Create a router utils from a client.
+ *
+ * @info Both client-side and server-side clients are supported.
+ * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/vue Tanstack Query Vue Docs}
+ */
+declare function createRouterUtils<T extends NestedClient<any>>(client: T, options?: CreateRouterUtilsOptions): RouterUtils<T>;
+
+type UnrefDeep<T> = T extends Ref<infer U> ? UnrefDeep<U> : T extends AnyFunction ? T : T extends object ? {
+    [K in keyof T]: UnrefDeep<T[K]>;
+} : T;
+declare function unrefDeep<T>(value: T): UnrefDeep<T>;
+
+export { createGeneralUtils, createRouterUtils as createORPCVueQueryUtils, createProcedureUtils, createRouterUtils, unrefDeep };
+export type { CreateProcedureUtilsOptions, CreateRouterUtilsOptions, GeneralUtils, InfiniteOptionsBase, InfiniteOptionsIn, MaybeRefDeep, MutationOptions, MutationOptionsIn, ProcedureUtils, QueryOptionsBase, QueryOptionsIn, RouterUtils, UnrefDeep, experimental_InferStreamedOutput, experimental_StreamedOptionsBase, experimental_StreamedOptionsIn };

package/dist/index.d.ts

@@ -0,0 +1,142 @@
+import { ClientContext, Client, NestedClient } from '@orpc/client';
+import { OperationType, OperationKeyOptions } from '@orpc/tanstack-query';
+export { OperationKeyOptions as BuildKeyOptions, OperationType as KeyType, generateOperationKey as buildKey } from '@orpc/tanstack-query';
+import { QueryKey, SkipToken, QueryObserverOptions, QueryFunctionContext, experimental_streamedQuery, InfiniteQueryObserverOptions, MutationObserverOptions, InfiniteData } from '@tanstack/vue-query';
+import { AnyFunction, MaybeOptionalOptions } from '@orpc/shared';
+import { MaybeRef, MaybeRefOrGetter, ComputedRef, Ref } from 'vue';
+
+interface GeneralUtils<TInput> {
+    /**
+     * Generate a query/mutation key for checking status, invalidate, set, get, etc.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/basic#query-mutation-key Tanstack Query/Mutation Key Docs}
+     */
+    key<UType extends OperationType>(options?: OperationKeyOptions<UType, TInput>): QueryKey;
+}
+declare function createGeneralUtils<TInput>(path: string[]): GeneralUtils<TInput>;
+
+/**
+ * Since `@tanstack/vue-query` is not exporting the type `MaybeRefDeep` we need to copy it from the source code.
+ * https://github.com/TanStack/query/blob/7ff544e12e79388e513b1cd886aeb946f80f0153/packages/vue-query/src/types.ts#L19C1-L27C2
+ */
+type MaybeRefDeep<T> = MaybeRef<T extends AnyFunction ? T : T extends object ? {
+    [Property in keyof T]: MaybeRefDeep<T[Property]>;
+} : T>;
+type QueryOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TSelectData> = (undefined extends TInput ? {
+    input?: MaybeRefDeep<TInput | SkipToken>;
+} : {
+    input: MaybeRefDeep<TInput | SkipToken>;
+}) & (Record<never, never> extends TClientContext ? {
+    context?: MaybeRefDeep<TClientContext>;
+} : {
+    context: MaybeRefDeep<TClientContext>;
+}) & {
+    [P in keyof Omit<QueryObserverOptions<TOutput, TError, TSelectData, TOutput>, 'queryKey' | 'enabled'>]: MaybeRefDeep<QueryObserverOptions<TOutput, TError, TSelectData, TOutput>[P]>;
+} & {
+    enabled?: MaybeRefOrGetter<QueryObserverOptions<TOutput, TError, TSelectData, TOutput>['enabled']>;
+    queryKey?: MaybeRefDeep<QueryObserverOptions<TOutput, TError, TSelectData, TOutput>['queryKey']>;
+    shallow?: boolean;
+};
+interface QueryOptionsBase<TOutput, TError> {
+    queryKey: ComputedRef<QueryKey>;
+    queryFn(ctx: QueryFunctionContext): Promise<TOutput>;
+    throwOnError?(error: TError): boolean;
+    retryDelay?: (count: number, error: TError) => number;
+    enabled: ComputedRef<boolean | undefined>;
+}
+type experimental_StreamedQueryOptions = Omit<Parameters<typeof experimental_streamedQuery>[0], 'queryFn'>;
+type experimental_InferStreamedOutput<TOutput> = TOutput extends AsyncIterable<infer U> ? U[] : never;
+type experimental_StreamedOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TSelectData> = QueryOptionsIn<TClientContext, TInput, TOutput, TError, TSelectData> & {
+    queryFnOptions?: experimental_StreamedQueryOptions;
+};
+interface experimental_StreamedOptionsBase<TOutput, TError> extends QueryOptionsBase<TOutput, TError> {
+}
+type InfiniteOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TSelectData, TPageParam> = (Record<never, never> extends TClientContext ? {
+    context?: MaybeRefDeep<TClientContext>;
+} : {
+    context: MaybeRefDeep<TClientContext>;
+}) & {
+    [Property in keyof Omit<InfiniteQueryObserverOptions<TOutput, TError, TSelectData, QueryKey, TPageParam>, 'queryKey' | 'enabled'>]: MaybeRefDeep<InfiniteQueryObserverOptions<TOutput, TError, TSelectData, QueryKey, TPageParam>[Property]>;
+} & {
+    input: MaybeRef<((pageParam: TPageParam) => MaybeRefDeep<TInput>) | SkipToken>;
+    enabled?: MaybeRefOrGetter<InfiniteQueryObserverOptions<TOutput, TError, TSelectData, QueryKey, TPageParam>['enabled']>;
+    queryKey?: MaybeRefDeep<InfiniteQueryObserverOptions<TOutput, TError, TSelectData, QueryKey, TPageParam>['queryKey']>;
+    shallow?: boolean;
+};
+interface InfiniteOptionsBase<TOutput, TError, TPageParam> {
+    queryKey: ComputedRef<QueryKey>;
+    queryFn(ctx: QueryFunctionContext<QueryKey, TPageParam>): Promise<TOutput>;
+    throwOnError?(error: TError): boolean;
+    retryDelay?: (count: number, error: TError) => number;
+    enabled: ComputedRef<boolean | undefined>;
+}
+type MutationOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TMutationContext> = (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+}) & MutationOptions<TInput, TOutput, TError, TMutationContext>;
+type MutationOptions<TInput, TOutput, TError, TMutationContext> = {
+    [P in keyof MutationObserverOptions<TOutput, TError, TInput, TMutationContext>]: MaybeRefDeep<MutationObserverOptions<TOutput, TError, TInput, TMutationContext>[P]>;
+} & {
+    shallow?: MaybeRef<boolean>;
+};
+
+interface ProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError> {
+    /**
+     * Calling corresponding procedure client
+     *
+     * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/basic#calling-procedure-clients Tanstack Calling Procedure Client Docs}
+     */
+    call: Client<TClientContext, TInput, TOutput, TError>;
+    /**
+     * Generate options used for useQuery/prefetchQuery/...
+     *
+     * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/basic#query-options-utility Tanstack Query Options Utility Docs}
+     */
+    queryOptions<U, USelectData = TOutput>(...rest: MaybeOptionalOptions<U & QueryOptionsIn<TClientContext, TInput, TOutput, TError, USelectData>>): NoInfer<U & Omit<QueryOptionsBase<TOutput, TError>, keyof U>>;
+    /**
+     * Generate [Event Iterator](https://orpc.unnoq.com/docs/event-iterator) options used for useQuery/prefetchQuery/...
+     * Built on top of [steamedQuery](https://tanstack.com/query/latest/docs/reference/streamedQuery)
+     *
+     * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/basic#streamed-query-options-utility Tanstack Streamed Query Options Utility Docs}
+     */
+    experimental_streamedOptions<U, USelectData = experimental_InferStreamedOutput<TOutput>>(...rest: MaybeOptionalOptions<U & experimental_StreamedOptionsIn<TClientContext, TInput, experimental_InferStreamedOutput<TOutput>, TError, USelectData>>): NoInfer<U & Omit<experimental_StreamedOptionsBase<experimental_InferStreamedOutput<TOutput>, TError>, keyof U>>;
+    /**
+     * Generate options used for useInfiniteQuery/prefetchInfiniteQuery/...
+     *
+     * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/basic#infinite-query-options-utility Tanstack Infinite Query Options Utility Docs}
+     */
+    infiniteOptions<U, UPageParam, USelectData = InfiniteData<TOutput, UPageParam>>(options: U & InfiniteOptionsIn<TClientContext, TInput, TOutput, TError, USelectData, UPageParam>): NoInfer<U & Omit<InfiniteOptionsBase<TOutput, TError, UPageParam>, keyof U>>;
+    /**
+     * Generate options used for useMutation/...
+     *
+     * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/basic#mutation-options Tanstack Mutation Options Docs}
+     */
+    mutationOptions<UMutationContext>(...rest: MaybeOptionalOptions<MutationOptionsIn<TClientContext, TInput, TOutput, TError, UMutationContext>>): MutationOptions<TInput, TOutput, TError, UMutationContext>;
+}
+interface CreateProcedureUtilsOptions {
+    path: string[];
+}
+declare function createProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError>(client: Client<TClientContext, TInput, TOutput, TError>, options: CreateProcedureUtilsOptions): ProcedureUtils<TClientContext, TInput, TOutput, TError>;
+
+type RouterUtils<T extends NestedClient<any>> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? ProcedureUtils<UClientContext, UInput, UOutput, UError> & GeneralUtils<UInput> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? RouterUtils<T[K]> : never;
+} & GeneralUtils<unknown>;
+interface CreateRouterUtilsOptions {
+    path?: string[];
+}
+/**
+ * Create a router utils from a client.
+ *
+ * @info Both client-side and server-side clients are supported.
+ * @see {@link https://orpc.unnoq.com/docs/integrations/tanstack-query-old/vue Tanstack Query Vue Docs}
+ */
+declare function createRouterUtils<T extends NestedClient<any>>(client: T, options?: CreateRouterUtilsOptions): RouterUtils<T>;
+
+type UnrefDeep<T> = T extends Ref<infer U> ? UnrefDeep<U> : T extends AnyFunction ? T : T extends object ? {
+    [K in keyof T]: UnrefDeep<T[K]>;
+} : T;
+declare function unrefDeep<T>(value: T): UnrefDeep<T>;
+
+export { createGeneralUtils, createRouterUtils as createORPCVueQueryUtils, createProcedureUtils, createRouterUtils, unrefDeep };
+export type { CreateProcedureUtilsOptions, CreateRouterUtilsOptions, GeneralUtils, InfiniteOptionsBase, InfiniteOptionsIn, MaybeRefDeep, MutationOptions, MutationOptionsIn, ProcedureUtils, QueryOptionsBase, QueryOptionsIn, RouterUtils, UnrefDeep, experimental_InferStreamedOutput, experimental_StreamedOptionsBase, experimental_StreamedOptionsIn };

package/dist/index.mjs

@@ -0,0 +1,126 @@
+import { generateOperationKey } from '@orpc/tanstack-query';
+export { generateOperationKey as buildKey } from '@orpc/tanstack-query';
+import { isObject, isAsyncIteratorObject } from '@orpc/shared';
+import { skipToken, experimental_streamedQuery } from '@tanstack/vue-query';
+import { isRef, computed } from 'vue';
+
+function createGeneralUtils(path) {
+  return {
+    key(options) {
+      return generateOperationKey(path, options);
+    }
+  };
+}
+
+function unrefDeep(value) {
+  if (isRef(value)) {
+    return unrefDeep(value.value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(unrefDeep);
+  }
+  if (isObject(value)) {
+    return Object.keys(value).reduce((acc, key) => {
+      acc[key] = unrefDeep(value[key]);
+      return acc;
+    }, {});
+  }
+  return value;
+}
+
+function createProcedureUtils(client, options) {
+  return {
+    call: client,
+    queryOptions(...[optionsIn = {}]) {
+      return {
+        queryKey: computed(() => generateOperationKey(options.path, { type: "query", input: unrefDeep(optionsIn.input) })),
+        queryFn: ({ signal }) => {
+          const input = unrefDeep(optionsIn.input);
+          if (input === skipToken) {
+            throw new Error("queryFn should not be called with skipToken used as input");
+          }
+          return client(input, { signal, context: unrefDeep(optionsIn.context) });
+        },
+        enabled: computed(() => unrefDeep(optionsIn.input) === skipToken ? false : void 0),
+        ...optionsIn
+      };
+    },
+    experimental_streamedOptions(...[optionsIn = {}]) {
+      return {
+        enabled: computed(() => unrefDeep(optionsIn.input) === skipToken ? false : void 0),
+        queryKey: computed(() => generateOperationKey(options.path, { type: "streamed", input: unrefDeep(optionsIn.input), fnOptions: optionsIn.queryFnOptions })),
+        queryFn: experimental_streamedQuery({
+          queryFn: async ({ signal }) => {
+            const input = unrefDeep(optionsIn.input);
+            if (input === skipToken) {
+              throw new Error("queryFn should not be called with skipToken used as input");
+            }
+            const output = await client(input, { signal, context: unrefDeep(optionsIn.context) });
+            if (!isAsyncIteratorObject(output)) {
+              throw new Error("streamedQuery requires an event iterator output");
+            }
+            return output;
+          },
+          ...optionsIn.queryFnOptions
+        }),
+        ...optionsIn
+      };
+    },
+    infiniteOptions(optionsIn) {
+      return {
+        queryKey: computed(() => {
+          const input = unrefDeep(optionsIn.input);
+          return generateOperationKey(options.path, {
+            type: "infinite",
+            input: input === skipToken ? skipToken : unrefDeep(input(unrefDeep(optionsIn.initialPageParam)))
+          });
+        }),
+        queryFn: ({ pageParam, signal }) => {
+          const input = unrefDeep(optionsIn.input);
+          if (input === skipToken) {
+            throw new Error("queryFn should not be called with skipToken used as input");
+          }
+          return client(unrefDeep(input(pageParam)), { signal, context: unrefDeep(optionsIn.context) });
+        },
+        enabled: computed(() => unrefDeep(optionsIn.input) === skipToken ? false : void 0),
+        ...optionsIn
+      };
+    },
+    mutationOptions(...[optionsIn = {}]) {
+      return {
+        mutationKey: generateOperationKey(options.path, { type: "mutation" }),
+        mutationFn: (input) => client(input, { context: unrefDeep(optionsIn.context) }),
+        ...optionsIn
+      };
+    }
+  };
+}
+
+function createRouterUtils(client, options = {}) {
+  const path = options.path ?? [];
+  const generalUtils = createGeneralUtils(path);
+  const procedureUtils = createProcedureUtils(client, { path });
+  const recursive = new Proxy({
+    ...generalUtils,
+    ...procedureUtils
+  }, {
+    get(target, prop) {
+      const value = Reflect.get(target, prop);
+      if (typeof prop !== "string") {
+        return value;
+      }
+      const nextUtils = createRouterUtils(client[prop], { ...options, path: [...path, prop] });
+      if (typeof value !== "function") {
+        return nextUtils;
+      }
+      return new Proxy(value, {
+        get(_, prop2) {
+          return Reflect.get(nextUtils, prop2);
+        }
+      });
+    }
+  });
+  return recursive;
+}
+
+export { createGeneralUtils, createRouterUtils as createORPCVueQueryUtils, createProcedureUtils, createRouterUtils, unrefDeep };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/vue-query",
   "type": "module",
-  "version": "0.0.0-next.ff5907c",
+  "version": "0.0.0-next.ff7ad2e",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -18,29 +18,28 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "peerDependencies": {
-    "@tanstack/vue-query": ">=5.50.0",
+    "@tanstack/vue-query": ">=5.80.2",
     "vue": ">=3.3.0",
-    "@orpc/client": "0.0.0-next.ff5907c"
+    "@orpc/client": "0.0.0-next.ff7ad2e"
   },
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.ff5907c"
+    "@orpc/shared": "0.0.0-next.ff7ad2e",
+    "@orpc/tanstack-query": "0.0.0-next.ff7ad2e"
+  },
+  "devDependencies": {
+    "@tanstack/vue-query": "^5.85.3"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/index.js

@@ -1,110 +0,0 @@
-// src/key.ts
-function buildKey(path, options) {
-  const withInput = options?.input !== void 0 ? { input: options?.input } : {};
-  const withType = options?.type !== void 0 ? { type: options?.type } : {};
-  return [path, {
-    ...withInput,
-    ...withType
-  }];
-}
-
-// src/general-utils.ts
-function createGeneralUtils(path) {
-  return {
-    key(options) {
-      return buildKey(path, options);
-    }
-  };
-}
-
-// src/procedure-utils.ts
-import { computed } from "vue";
-
-// src/utils.ts
-import { isObject } from "@orpc/shared";
-import { isRef } from "vue";
-function unrefDeep(value) {
-  if (isRef(value)) {
-    return unrefDeep(value.value);
-  }
-  if (Array.isArray(value)) {
-    return value.map(unrefDeep);
-  }
-  if (isObject(value)) {
-    return Object.keys(value).reduce((acc, key) => {
-      acc[key] = unrefDeep(value[key]);
-      return acc;
-    }, {});
-  }
-  return value;
-}
-
-// src/procedure-utils.ts
-function createProcedureUtils(client, path) {
-  return {
-    call: client,
-    queryOptions(...[{ input, context, ...rest } = {}]) {
-      return {
-        queryKey: computed(() => buildKey(path, { type: "query", input: unrefDeep(input) })),
-        queryFn: ({ signal }) => client(unrefDeep(input), { signal, context: unrefDeep(context) }),
-        ...rest
-      };
-    },
-    infiniteOptions({ input, context, ...rest }) {
-      return {
-        queryKey: computed(() => {
-          return buildKey(path, { type: "infinite", input: unrefDeep(input(unrefDeep(rest.initialPageParam))) });
-        }),
-        queryFn: ({ pageParam, signal }) => {
-          return client(unrefDeep(input(pageParam)), { signal, context: unrefDeep(context) });
-        },
-        ...rest
-      };
-    },
-    mutationOptions(...[{ context, ...rest } = {}]) {
-      return {
-        mutationKey: buildKey(path, { type: "mutation" }),
-        mutationFn: (input) => client(input, { context: unrefDeep(context) }),
-        ...rest
-      };
-    }
-  };
-}
-
-// src/router-utils.ts
-function createRouterUtils(client, path = []) {
-  const generalUtils = createGeneralUtils(path);
-  const procedureUtils = createProcedureUtils(client, path);
-  const recursive = new Proxy({
-    ...generalUtils,
-    ...procedureUtils
-  }, {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-      if (typeof prop !== "string") {
-        return value;
-      }
-      const nextUtils = createRouterUtils(client[prop], [...path, prop]);
-      if (typeof value !== "function") {
-        return nextUtils;
-      }
-      return new Proxy(value, {
-        get(_, prop2) {
-          return Reflect.get(nextUtils, prop2);
-        }
-      });
-    }
-  });
-  return recursive;
-}
-
-// src/index.ts
-var createORPCVueQueryUtils = createRouterUtils;
-export {
-  buildKey,
-  createGeneralUtils,
-  createORPCVueQueryUtils,
-  createProcedureUtils,
-  createRouterUtils
-};
-//# sourceMappingURL=index.js.map

package/dist/src/general-utils.d.ts

@@ -1,7 +0,0 @@
-import type { QueryKey } from '@tanstack/vue-query';
-import type { BuildKeyOptions, KeyType } from './key';
-export interface GeneralUtils<TInput> {
-    key<UType extends KeyType = undefined>(options?: BuildKeyOptions<UType, TInput>): QueryKey;
-}
-export declare function createGeneralUtils<TInput>(path: string[]): GeneralUtils<TInput>;
-//# sourceMappingURL=general-utils.d.ts.map

package/dist/src/index.d.ts

@@ -1,8 +0,0 @@
-import { createRouterUtils } from './router-utils';
-export * from './general-utils';
-export * from './key';
-export * from './procedure-utils';
-export * from './router-utils';
-export * from './types';
-export declare const createORPCVueQueryUtils: typeof createRouterUtils;
-//# sourceMappingURL=index.d.ts.map

package/dist/src/key.d.ts

@@ -1,9 +0,0 @@
-import type { PartialDeep } from '@orpc/shared';
-import type { QueryKey } from '@tanstack/vue-query';
-export type KeyType = 'query' | 'infinite' | 'mutation' | undefined;
-export interface BuildKeyOptions<TType extends KeyType, TInput> {
-    type?: TType;
-    input?: TType extends 'mutation' ? never : PartialDeep<TInput>;
-}
-export declare function buildKey<TType extends KeyType, TInput>(path: string[], options?: BuildKeyOptions<TType, TInput>): QueryKey;
-//# sourceMappingURL=key.d.ts.map

package/dist/src/procedure-utils.d.ts

@@ -1,12 +0,0 @@
-import type { Client, ClientContext } from '@orpc/client';
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { InfiniteData } from '@tanstack/vue-query';
-import type { InfiniteOptionsBase, InfiniteOptionsIn, MutationOptionsBase, MutationOptionsIn, QueryOptionsBase, QueryOptionsIn } from './types';
-export interface ProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
-    call: Client<TClientContext, TInput, TOutput, TError>;
-    queryOptions<U, USelectData = TOutput>(...rest: MaybeOptionalOptions<U & QueryOptionsIn<TClientContext, TInput, TOutput, TError, USelectData>>): NoInfer<U & QueryOptionsBase<TOutput, TError>>;
-    infiniteOptions<U, UPageParam, USelectData = InfiniteData<TOutput, UPageParam>>(options: U & InfiniteOptionsIn<TClientContext, TInput, TOutput, TError, USelectData, UPageParam>): NoInfer<U & InfiniteOptionsBase<TOutput, TError, UPageParam>>;
-    mutationOptions<U>(...rest: MaybeOptionalOptions<U & MutationOptionsIn<TClientContext, TInput, TOutput, TError>>): NoInfer<U & MutationOptionsBase<TInput, TOutput, TError>>;
-}
-export declare function createProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError extends Error>(client: Client<TClientContext, TInput, TOutput, TError>, path: string[]): ProcedureUtils<TClientContext, TInput, TOutput, TError>;
-//# sourceMappingURL=procedure-utils.d.ts.map

package/dist/src/router-utils.d.ts

@@ -1,12 +0,0 @@
-import type { Client, NestedClient } from '@orpc/client';
-import { type GeneralUtils } from './general-utils';
-import { type ProcedureUtils } from './procedure-utils';
-export type RouterUtils<T extends NestedClient<any>> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? ProcedureUtils<UClientContext, UInput, UOutput, UError> & GeneralUtils<UInput> : {
-    [K in keyof T]: T[K] extends NestedClient<any> ? RouterUtils<T[K]> : never;
-} & GeneralUtils<unknown>;
-/**
- * @param client - Any kind of oRPC clients: `createRouterClient`, `createORPCClient`, ...
- * @param path - The base path for query key, when it it will be prefix to all keys
- */
-export declare function createRouterUtils<T extends NestedClient<any>>(client: T, path?: string[]): RouterUtils<T>;
-//# sourceMappingURL=router-utils.d.ts.map

package/dist/src/types.d.ts

@@ -1,58 +0,0 @@
-import type { ClientContext } from '@orpc/client';
-import type { AnyFunction, SetOptional } from '@orpc/shared';
-import type { Enabled, MutationObserverOptions, QueryFunctionContext, QueryKey, QueryObserverOptions, UseInfiniteQueryOptions } from '@tanstack/vue-query';
-import type { ComputedRef, MaybeRef, MaybeRefOrGetter } from 'vue';
-/**
- * Since `@tanstack/vue-query` is not exporting the type `MaybeRefDeep` we need to copy it from the source code.
- * https://github.com/TanStack/query/blob/7ff544e12e79388e513b1cd886aeb946f80f0153/packages/vue-query/src/types.ts#L19C1-L27C2
- */
-export type MaybeRefDeep<T> = MaybeRef<T extends AnyFunction ? T : T extends object ? {
-    [Property in keyof T]: MaybeRefDeep<T[Property]>;
-} : T>;
-export type QueryOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError extends Error, TSelectData> = (undefined extends TInput ? {
-    input?: MaybeRefDeep<TInput>;
-} : {
-    input: MaybeRefDeep<TInput>;
-}) & (Record<never, never> extends TClientContext ? {
-    context?: MaybeRefDeep<TClientContext>;
-} : {
-    context: MaybeRefDeep<TClientContext>;
-}) & {
-    [P in keyof Omit<QueryObserverOptions<TOutput, TError, TSelectData, TOutput>, 'queryKey' | 'enabled'>]: MaybeRefDeep<QueryObserverOptions<TOutput, TError, TSelectData, TOutput>[P]>;
-} & {
-    enabled?: MaybeRefOrGetter<Enabled<TOutput, TError, TSelectData>>;
-    queryKey?: MaybeRefDeep<QueryKey>;
-    shallow?: boolean;
-};
-export interface QueryOptionsBase<TOutput, TError extends Error> {
-    queryKey: ComputedRef<QueryKey>;
-    queryFn(ctx: QueryFunctionContext): Promise<TOutput>;
-    retry?(failureCount: number, error: TError): boolean;
-}
-export type InfiniteOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError extends Error, TSelectData, TPageParam> = {
-    input: (pageParam: TPageParam) => MaybeRefDeep<TInput>;
-} & (Record<never, never> extends TClientContext ? {
-    context?: MaybeRefDeep<TClientContext>;
-} : {
-    context: MaybeRefDeep<TClientContext>;
-}) & SetOptional<UseInfiniteQueryOptions<TOutput, TError, TSelectData, TOutput, QueryKey, TPageParam>, 'queryKey'>;
-export interface InfiniteOptionsBase<TOutput, TError extends Error, TPageParam> {
-    queryKey: ComputedRef<QueryKey>;
-    queryFn(ctx: QueryFunctionContext<QueryKey, TPageParam>): Promise<TOutput>;
-    retry?(failureCount: number, error: TError): boolean;
-}
-export type MutationOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> = (Record<never, never> extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-}) & {
-    [P in keyof MutationObserverOptions<TOutput, TError, TInput>]: MaybeRefDeep<MutationObserverOptions<TOutput, TError, TInput>[P]>;
-} & {
-    shallow?: MaybeRef<boolean>;
-};
-export interface MutationOptionsBase<TInput, TOutput, TError extends Error> {
-    mutationKey: QueryKey;
-    mutationFn(input: TInput): Promise<TOutput>;
-    retry?(failureCount: number, error: TError): boolean;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/utils.d.ts

@@ -1,7 +0,0 @@
-import type { Ref } from 'vue';
-import { type AnyFunction } from '@orpc/shared';
-export type UnrefDeep<T> = T extends Ref<infer U> ? UnrefDeep<U> : T extends AnyFunction ? T : T extends object ? {
-    [K in keyof T]: UnrefDeep<T[K]>;
-} : T;
-export declare function unrefDeep<T>(value: T): UnrefDeep<T>;
-//# sourceMappingURL=utils.d.ts.map