@orpc/vue-query 0.36.1 → 0.37.0

package/dist/index.js

@@ -2,77 +2,81 @@
 function buildKey(path, options) {
   const withInput = options?.input !== void 0 ? { input: options?.input } : {};
   const withType = options?.type !== void 0 ? { type: options?.type } : {};
-  return [
-    "__ORPC__",
-    path,
-    {
-      ...withInput,
-      ...withType
-    }
-  ];
+  return [path, {
+    ...withInput,
+    ...withType
+  }];
+}
+
+// ../shared/src/object.ts
+function isObject(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
 }
 
 // src/utils.ts
 import { isRef } from "vue";
-function deepUnref(value) {
+function unrefDeep(value) {
   if (isRef(value)) {
-    return deepUnref(value.value);
+    return unrefDeep(value.value);
   }
   if (Array.isArray(value)) {
-    return value.map(deepUnref);
+    return value.map(unrefDeep);
   }
-  if (value && typeof value === "object") {
+  if (isObject(value)) {
     return Object.keys(value).reduce((acc, key) => {
-      acc[key] = deepUnref(value[key]);
+      acc[key] = unrefDeep(value[key]);
       return acc;
     }, {});
   }
   return value;
 }
 
-// src/utils-general.ts
+// src/general-utils.ts
 function createGeneralUtils(path) {
   return {
     key(options) {
-      return buildKey(path, deepUnref(options));
+      return buildKey(path, unrefDeep(options));
     }
   };
 }
 
-// src/utils-procedure.ts
+// src/procedure-utils.ts
 import { computed } from "vue";
 function createProcedureUtils(client, path) {
   return {
-    queryOptions(...[options]) {
-      const input = options?.input;
+    queryOptions(...[{ input, context, ...rest } = {}]) {
       return {
-        queryKey: computed(() => buildKey(path, { type: "query", input: deepUnref(input) })),
-        queryFn: ({ signal }) => client(deepUnref(input), { signal, context: deepUnref(options?.context) }),
-        ...options
+        queryKey: computed(() => buildKey(path, { type: "query", input: unrefDeep(input) })),
+        queryFn: ({ signal }) => client(unrefDeep(input), { signal, context: unrefDeep(context) }),
+        ...rest
       };
     },
-    infiniteOptions(options) {
-      const input = options.input;
+    infiniteOptions({ input, context, ...rest }) {
       return {
-        initialPageParam: void 0,
-        queryKey: computed(() => buildKey(path, { type: "infinite", input: deepUnref(input) })),
+        queryKey: computed(() => {
+          return buildKey(path, { type: "infinite", input: unrefDeep(input(unrefDeep(rest.initialPageParam))) });
+        }),
         queryFn: ({ pageParam, signal }) => {
-          return client({ ...deepUnref(input), cursor: pageParam }, { signal, context: deepUnref(options.context) });
+          return client(unrefDeep(input(pageParam)), { signal, context: unrefDeep(context) });
         },
-        ...options
+        ...rest
       };
     },
-    mutationOptions(...[options]) {
+    mutationOptions(...[{ context, ...rest } = {}]) {
       return {
         mutationKey: buildKey(path, { type: "mutation" }),
-        mutationFn: (input) => client(input, { context: deepUnref(options?.context) }),
-        ...options
+        mutationFn: (input) => client(input, { context: unrefDeep(context) }),
+        ...rest
       };
     }
   };
 }
 
-// src/utils-router.ts
+// src/router-utils.ts
 function createRouterUtils(client, path = []) {
   const generalUtils = createGeneralUtils(path);
   const procedureUtils = createProcedureUtils(client, path);

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

@@ -0,0 +1,8 @@
+import type { QueryKey } from '@tanstack/vue-query';
+import type { BuildKeyOptions, KeyType } from './key';
+import type { MaybeRefDeep } from './types';
+export interface GeneralUtils<TInput> {
+    key<UType extends KeyType = undefined>(options?: MaybeRefDeep<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 +1,8 @@
-import { createRouterUtils } from './utils-router';
+import { createRouterUtils } from './router-utils';
+export * from './general-utils';
 export * from './key';
+export * from './procedure-utils';
+export * from './router-utils';
 export * from './types';
-export * from './utils-general';
-export * from './utils-procedure';
-export * from './utils-router';
 export declare const createORPCVueQueryUtils: typeof createRouterUtils;
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+import type { Client } from '@orpc/contract';
+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, TInput, TOutput, TError extends Error> {
+    queryOptions<U, USelectData = TOutput>(...rest: MaybeOptionalOptions<U & QueryOptionsIn<TClientContext, TInput, TOutput, TError, USelectData>>): NoInfer<U & QueryOptionsBase<TOutput, TError>>;
+    infiniteOptions<U, UPageParam, USelectData = InfiniteData<TOutput>>(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, 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

@@ -0,0 +1,12 @@
+import type { Client, NestedClient } from '@orpc/contract';
+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,53 +1,51 @@
 import type { AnyFunction, SetOptional } from '@orpc/shared';
-import type { MutationObserverOptions, QueryFunctionContext, QueryKey, QueryObserverOptions, UseInfiniteQueryOptions } from '@tanstack/vue-query';
+import type { Enabled, MutationObserverOptions, QueryFunctionContext, QueryKey, QueryObserverOptions, UseInfiniteQueryOptions } from '@tanstack/vue-query';
 import type { ComputedRef, MaybeRef, MaybeRefOrGetter } from 'vue';
-export type MaybeDeepRef<T> = MaybeRef<T extends AnyFunction ? T : T extends object ? {
-    [K in keyof T]: MaybeDeepRef<T[K]>;
+/**
+ * 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 NonUndefinedGuard<T> = T extends undefined ? never : T;
-export type InferCursor<T> = T extends {
-    cursor?: any;
-} ? T['cursor'] : never;
-export type QueryOptionsExtra<TClientContext, TInput, TOutput, TError extends Error, TSelectData> = (undefined extends TInput ? {
-    input?: MaybeDeepRef<TInput>;
+export type QueryOptionsIn<TClientContext, TInput, TOutput, TError extends Error, TSelectData> = (undefined extends TInput ? {
+    input?: MaybeRefDeep<TInput>;
 } : {
-    input: MaybeDeepRef<TInput>;
+    input: MaybeRefDeep<TInput>;
 }) & (undefined extends TClientContext ? {
-    context?: MaybeDeepRef<TClientContext>;
+    context?: MaybeRefDeep<TClientContext>;
 } : {
-    context: MaybeDeepRef<TClientContext>;
-}) & SetOptional<{
-    [P in keyof QueryObserverOptions<TOutput, TError, TSelectData, TOutput, QueryKey>]: P extends 'enabled' ? MaybeRefOrGetter<QueryObserverOptions<TOutput, TError, TSelectData, TOutput, QueryKey>[P]> : MaybeDeepRef<QueryObserverOptions<TOutput, TError, TSelectData, TOutput, QueryKey>[P]>;
-}, 'queryKey'> & {
-    shallow?: MaybeRef<boolean>;
-    initialData?: NonUndefinedGuard<TOutput> | (() => NonUndefinedGuard<TOutput>) | undefined;
+    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 InfiniteOptionsExtra<TClientContext, TInput, TOutput, TError extends Error, TSelectData> = (undefined extends TInput ? {
-    input?: MaybeDeepRef<Omit<TInput, 'cursor'>>;
-} : {
-    input: MaybeDeepRef<Omit<TInput, 'cursor'>>;
-}) & (undefined extends TClientContext ? {
-    context?: MaybeDeepRef<TClientContext>;
+export type InfiniteOptionsIn<TClientContext, TInput, TOutput, TError extends Error, TSelectData, TPageParam> = {
+    input: (pageParam: TPageParam) => MaybeRefDeep<TInput>;
+} & (undefined extends TClientContext ? {
+    context?: MaybeRefDeep<TClientContext>;
 } : {
-    context: MaybeDeepRef<TClientContext>;
-}) & SetOptional<UseInfiniteQueryOptions<TOutput, TError, TSelectData, TOutput, QueryKey, InferCursor<TInput>>, 'queryKey' | (undefined extends InferCursor<TInput> ? 'initialPageParam' : never)>;
-export interface InfiniteOptionsBase<TInput, TOutput, TError extends Error> {
+    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, InferCursor<TInput>>): Promise<TOutput>;
-    initialPageParam: undefined;
+    queryFn(ctx: QueryFunctionContext<QueryKey, TPageParam>): Promise<TOutput>;
     retry?(failureCount: number, error: TError): boolean;
 }
-export type MutationOptionsExtra<TClientContext, TInput, TOutput, TError extends Error> = (undefined extends TClientContext ? {
-    context?: MaybeDeepRef<TClientContext>;
+export type MutationOptionsIn<TClientContext, TInput, TOutput, TError extends Error> = (undefined extends TClientContext ? {
+    context?: TClientContext;
 } : {
-    context: MaybeDeepRef<TClientContext>;
+    context: TClientContext;
 }) & {
-    [P in keyof MutationObserverOptions<TOutput, TError, TInput, unknown>]: MaybeDeepRef<MutationObserverOptions<TOutput, TError, TInput, unknown>[P]>;
+    [P in keyof MutationObserverOptions<TOutput, TError, TInput>]: MaybeRefDeep<MutationObserverOptions<TOutput, TError, TInput>[P]>;
 } & {
     shallow?: MaybeRef<boolean>;
 };

package/dist/src/utils.d.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/vue-query",
   "type": "module",
-  "version": "0.36.1",
+  "version": "0.37.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -34,8 +34,8 @@
   "peerDependencies": {
     "@tanstack/vue-query": ">=5.50.0",
     "vue": ">=3.3.0",
-    "@orpc/client": "0.36.1",
-    "@orpc/contract": "0.36.1"
+    "@orpc/contract": "0.37.0",
+    "@orpc/client": "0.37.0"
   },
   "scripts": {
     "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",

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

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

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

@@ -1,13 +0,0 @@
-import type { Client } from '@orpc/contract';
-import type { IsEqual } from '@orpc/shared';
-import type { InfiniteOptionsBase, InfiniteOptionsExtra, MutationOptionsBase, MutationOptionsExtra, QueryOptionsBase, QueryOptionsExtra } from './types';
-/**
- * Utils at procedure level
- */
-export interface ProcedureUtils<TClientContext, TInput, TOutput, TError extends Error> {
-    queryOptions<U extends QueryOptionsExtra<TClientContext, TInput, TOutput, TError, any>>(...opt: [options: U] | (undefined extends TInput & TClientContext ? [] : never)): IsEqual<U, QueryOptionsExtra<TClientContext, TInput, TOutput, TError, any>> extends true ? QueryOptionsBase<TOutput, TError> : Omit<QueryOptionsBase<TOutput, TError>, keyof U> & U;
-    infiniteOptions<U extends InfiniteOptionsExtra<TClientContext, TInput, TOutput, TError, any>>(options: U): Omit<InfiniteOptionsBase<TInput, TOutput, TError>, keyof U> & U;
-    mutationOptions<U extends MutationOptionsExtra<TClientContext, TInput, TOutput, TError>>(...opt: [options: U] | (undefined extends TClientContext ? [] : never)): IsEqual<U, MutationOptionsExtra<TClientContext, TInput, TOutput, TError>> extends true ? MutationOptionsBase<TInput, TOutput, TError> : Omit<MutationOptionsBase<TInput, TOutput, TError>, keyof U> & U;
-}
-export declare function createProcedureUtils<TClientContext, TInput, TOutput, TError extends Error>(client: Client<TClientContext, TInput, TOutput, TError>, path: string[]): ProcedureUtils<TClientContext, TInput, TOutput, TError>;
-//# sourceMappingURL=utils-procedure.d.ts.map

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

@@ -1,12 +0,0 @@
-import type { Client, NestedClient } from '@orpc/contract';
-import { type GeneralUtils } from './utils-general';
-import { type ProcedureUtils } from './utils-procedure';
-export type RouterUtils<T extends NestedClient<any>> = T extends Client<infer TClientContext, infer UInput, infer UOutput, infer UError> ? ProcedureUtils<TClientContext, UInput, UOutput, UError> & GeneralUtils<UInput> : {
-    [K in keyof T]: T[K] extends NestedClient<any> ? RouterUtils<T[K]> : never;
-} & GeneralUtils<unknown>;
-/**
- * @param client - The client create form `@orpc/client`
- * @param path - The base path for query key
- */
-export declare function createRouterUtils<T extends NestedClient<any>>(client: T, path?: string[]): RouterUtils<T>;
-//# sourceMappingURL=utils-router.d.ts.map