@orpc/vue-colada 0.0.0-next.fd1db03 → 0.0.0-next.ff5907c

package/dist/index.js

@@ -1,63 +1,65 @@
 // src/key.ts
-import { SuperJSON } from "@orpc/server/fetch";
+import { serializeRPCJson } from "@orpc/client/rpc";
 function buildKey(path, options) {
   return [
-    "__ORPC__",
     ...path,
-    ...options?.input !== void 0 ? [{ input: JSON.stringify(SuperJSON.serialize(options.input)) }] : []
+    ...options?.input !== void 0 ? [{ input: JSON.stringify(serializeRPCJson(options.input)) }] : []
   ];
 }
 
+// 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 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
-function createGeneralUtils(path) {
-  return {
-    key(options) {
-      return buildKey(path, deepUnref(options));
-    }
-  };
-}
-
-// src/utils-procedure.ts
-import { computed } from "vue";
+// src/procedure-utils.ts
 function createProcedureUtils(client, path) {
   return {
-    queryOptions(...[options]) {
-      const input = options?.input;
+    call: client,
+    queryOptions(...[{ input, context, ...rest } = {}]) {
       return {
-        key: computed(() => buildKey(path, { input: deepUnref(input) })),
-        query: ({ signal }) => client(deepUnref(input), { signal, context: deepUnref(options?.context) }),
-        ...options
+        key: computed(() => buildKey(path, { input: unrefDeep(input) })),
+        query: ({ signal }) => client(unrefDeep(input), { signal, context: unrefDeep(context) }),
+        ...rest
       };
     },
-    mutationOptions(...[options]) {
+    mutationOptions(...[{ context, ...rest } = {}]) {
       return {
         key: (input) => buildKey(path, { input }),
-        mutation: (input, _) => client(input, { context: deepUnref(options?.context) }),
-        ...options
+        mutation: (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/{utils-general.d.ts → general-utils.d.ts}

@@ -1,11 +1,7 @@
 import type { EntryKey } from '@pinia/colada';
 import type { BuildKeyOptions } from './key';
-import type { MaybeDeepRef } from './types';
-/**
- * Utils at any level (procedure or router)
- */
 export interface GeneralUtils<TInput> {
-    key: (options?: MaybeDeepRef<BuildKeyOptions<TInput>>) => EntryKey;
+    key(options?: BuildKeyOptions<TInput>): EntryKey;
 }
 export declare function createGeneralUtils<TInput>(path: string[]): GeneralUtils<TInput>;
-//# sourceMappingURL=utils-general.d.ts.map
+//# 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 createORPCVueColadaUtils: typeof createRouterUtils;
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,10 @@
+import type { Client, ClientContext } from '@orpc/client';
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { MutationOptions, MutationOptionsIn, QueryOptions, QueryOptionsIn } from './types';
+export interface ProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
+    call: Client<TClientContext, TInput, TOutput, TError>;
+    queryOptions(...rest: MaybeOptionalOptions<QueryOptionsIn<TClientContext, TInput, TOutput, TError>>): QueryOptions<TOutput, TError>;
+    mutationOptions(...rest: MaybeOptionalOptions<MutationOptionsIn<TClientContext, TInput, TOutput, TError>>): MutationOptions<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

@@ -0,0 +1,12 @@
+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,25 +1,25 @@
+import type { ClientContext } from '@orpc/client';
 import type { AnyFunction, SetOptional } from '@orpc/shared';
 import type { UseMutationOptions, UseQueryOptions } from '@pinia/colada';
 import type { MaybeRef } from 'vue';
-export type MaybeDeepRef<T> = MaybeRef<T extends AnyFunction ? T : T extends object ? {
-    [K in keyof T]: MaybeDeepRef<T[K]>;
+export type MaybeRefDeep<T> = MaybeRef<T extends AnyFunction ? T : T extends object ? {
+    [K in keyof T]: MaybeRefDeep<T[K]>;
 } : T>;
 export type UseQueryFnContext = Parameters<UseQueryOptions<any>['query']>[0];
-export type InferCursor<T> = T extends {
-    cursor?: any;
-} ? T['cursor'] : never;
-export type QueryOptions<TInput, TOutput, TClientContext> = (undefined extends TInput ? {
-    input?: MaybeDeepRef<TInput>;
+export type QueryOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> = (undefined extends TInput ? {
+    input?: MaybeRefDeep<TInput>;
 } : {
-    input: MaybeDeepRef<TInput>;
-}) & (undefined extends TClientContext ? {
-    context?: MaybeDeepRef<TClientContext>;
+    input: MaybeRefDeep<TInput>;
+}) & (Record<never, never> extends TClientContext ? {
+    context?: MaybeRefDeep<TClientContext>;
 } : {
-    context: MaybeDeepRef<TClientContext>;
-}) & SetOptional<UseQueryOptions<TOutput>, 'key' | 'query'>;
-export type MutationOptions<TInput, TOutput, TClientContext> = (undefined extends TClientContext ? {
-    context?: MaybeDeepRef<TClientContext>;
+    context: MaybeRefDeep<TClientContext>;
+}) & SetOptional<UseQueryOptions<TOutput, TError>, 'key' | 'query'>;
+export type QueryOptions<TOutput, TError extends Error> = UseQueryOptions<TOutput, TError>;
+export type MutationOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> = (Record<never, never> extends TClientContext ? {
+    context?: MaybeRefDeep<TClientContext>;
 } : {
-    context: MaybeDeepRef<TClientContext>;
-}) & SetOptional<UseMutationOptions<TOutput, TInput>, 'mutation'>;
+    context: MaybeRefDeep<TClientContext>;
+}) & SetOptional<UseMutationOptions<TOutput, TInput, TError>, 'mutation'>;
+export type MutationOptions<TInput, TOutput, TError extends Error> = UseMutationOptions<TOutput, TInput, TError>;
 //# sourceMappingURL=types.d.ts.map

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-colada",
   "type": "module",
-  "version": "0.0.0-next.fd1db03",
+  "version": "0.0.0-next.ff5907c",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -33,18 +33,14 @@
     "dist"
   ],
   "peerDependencies": {
-    "@pinia/colada": ">=0.13.1",
-    "vue": ">=3.3.0",
-    "@orpc/server": "0.0.0-next.fd1db03",
-    "@orpc/contract": "0.0.0-next.fd1db03",
-    "@orpc/client": "0.0.0-next.fd1db03"
+    "@pinia/colada": ">=0.13.5",
+    "vue": ">=3.3.0"
   },
   "dependencies": {
-    "@orpc/server": "0.0.0-next.fd1db03"
+    "@orpc/client": "0.0.0-next.ff5907c",
+    "@orpc/shared": "0.0.0-next.ff5907c"
   },
   "devDependencies": {
-    "@pinia/colada": "^0.13.1",
-    "@vue/test-utils": "^2.4.6",
     "pinia": "^2.3.0"
   },
   "scripts": {

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

@@ -1,26 +0,0 @@
-import type { ProcedureClient } from '@orpc/server';
-import type { IsEqual } from '@orpc/shared';
-import type { EntryKey } from '@pinia/colada';
-import type { ComputedRef } from 'vue';
-import type { MutationOptions, QueryOptions, UseQueryFnContext } from './types';
-/**
- * Utils at procedure level
- */
-export interface ProcedureUtils<TInput, TOutput, TClientContext> {
-    queryOptions: <U extends QueryOptions<TInput, TOutput, TClientContext>>(...opt: [options: U] | (undefined extends TInput & TClientContext ? [] : never)) => IsEqual<U, QueryOptions<TInput, TOutput, TClientContext>> extends true ? {
-        key: ComputedRef<EntryKey>;
-        query: (ctx: UseQueryFnContext) => Promise<TOutput>;
-    } : Omit<{
-        key: ComputedRef<EntryKey>;
-        query: (ctx: UseQueryFnContext) => Promise<TOutput>;
-    }, keyof U> & U;
-    mutationOptions: <U extends MutationOptions<TInput, TOutput, TClientContext>>(...opt: [options: U] | (undefined extends TClientContext ? [] : never)) => IsEqual<U, MutationOptions<TInput, TOutput, TClientContext>> extends true ? {
-        key: (input: TInput) => EntryKey;
-        mutation: (input: TInput) => Promise<TOutput>;
-    } : Omit<{
-        key: (input: TInput) => EntryKey;
-        mutation: (input: TInput) => Promise<TOutput>;
-    }, keyof U> & U;
-}
-export declare function createProcedureUtils<TInput, TOutput, TClientContext>(client: ProcedureClient<TInput, TOutput, TClientContext>, path: string[]): ProcedureUtils<TInput, TOutput, TClientContext>;
-//# sourceMappingURL=utils-procedure.d.ts.map

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

@@ -1,12 +0,0 @@
-import type { ProcedureClient, RouterClient } from '@orpc/server';
-import { type GeneralUtils } from './utils-general';
-import { type ProcedureUtils } from './utils-procedure';
-export type RouterUtils<T extends RouterClient<any, any>> = T extends ProcedureClient<infer TInput, infer TOutput, infer TClientContext> ? ProcedureUtils<TInput, TOutput, TClientContext> & GeneralUtils<TInput> : {
-    [K in keyof T]: T[K] extends RouterClient<any, 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 RouterClient<any, any>>(client: T, path?: string[]): RouterUtils<T>;
-//# sourceMappingURL=utils-router.d.ts.map