@orpc/vue-query 0.0.0-next.18dacf3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 oRPC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -0,0 +1,108 @@
+// 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 [
+    "__ORPC__",
+    path,
+    {
+      ...withInput,
+      ...withType
+    }
+  ];
+}
+
+// src/utils.ts
+import { isRef } from "vue";
+function deepUnref(value) {
+  if (isRef(value)) {
+    return deepUnref(value.value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(deepUnref);
+  }
+  if (value && typeof value === "object") {
+    return Object.keys(value).reduce((acc, key) => {
+      acc[key] = deepUnref(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";
+function createProcedureUtils(client, path) {
+  return {
+    queryOptions(...[options]) {
+      const input = options?.input;
+      return {
+        queryKey: computed(() => buildKey(path, { type: "query", input: deepUnref(input) })),
+        queryFn: ({ signal }) => client(deepUnref(input), { signal }),
+        ...options
+      };
+    },
+    infiniteOptions(options) {
+      const input = options.input;
+      return {
+        queryKey: computed(() => buildKey(path, { type: "infinite", input: deepUnref(input) })),
+        queryFn: ({ pageParam, signal }) => client({ ...deepUnref(input), cursor: pageParam }, { signal }),
+        ...options
+      };
+    },
+    mutationOptions(options) {
+      return {
+        mutationKey: buildKey(path, { type: "mutation" }),
+        mutationFn: (input) => client(input),
+        ...options
+      };
+    }
+  };
+}
+
+// src/utils-router.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/index.d.ts

@@ -0,0 +1,8 @@
+import { createRouterUtils } from './utils-router';
+export * from './key';
+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/key.d.ts

@@ -0,0 +1,9 @@
+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/types.d.ts

@@ -0,0 +1,31 @@
+import type { AnyFunction, SetOptional } from '@orpc/shared';
+import type { DefaultError, MutationObserverOptions, QueryKey, QueryObserverOptions, UseInfiniteQueryOptions } from '@tanstack/vue-query';
+import type { MaybeRef, MaybeRefOrGetter } from 'vue';
+export type MaybeDeepRef<T> = MaybeRef<T extends AnyFunction ? T : T extends object ? {
+    [K in keyof T]: MaybeDeepRef<T[K]>;
+} : T>;
+export type NonUndefinedGuard<T> = T extends undefined ? never : T;
+export type InferCursor<T> = T extends {
+    cursor?: any;
+} ? T['cursor'] : never;
+export type QueryOptions<TInput, TOutput, TSelectData> = (undefined extends TInput ? {
+    input?: MaybeDeepRef<TInput>;
+} : {
+    input: MaybeDeepRef<TInput>;
+}) & SetOptional<{
+    [P in keyof QueryObserverOptions<TOutput, DefaultError, TSelectData, TOutput, QueryKey>]: P extends 'enabled' ? MaybeRefOrGetter<MaybeDeepRef<QueryObserverOptions<TOutput, DefaultError, TSelectData, TOutput, QueryKey>[P]>> : MaybeDeepRef<QueryObserverOptions<TOutput, DefaultError, TSelectData, TOutput, QueryKey>[P]>;
+}, 'queryKey'> & {
+    shallow?: MaybeRef<boolean>;
+    initialData?: NonUndefinedGuard<TOutput> | (() => NonUndefinedGuard<TOutput>) | undefined;
+};
+export type InfiniteOptions<TInput, TOutput, TSelectData> = (undefined extends TInput ? {
+    input?: MaybeDeepRef<Omit<TInput, 'cursor'>>;
+} : {
+    input: MaybeDeepRef<Omit<TInput, 'cursor'>>;
+}) & SetOptional<UseInfiniteQueryOptions<TOutput, DefaultError, TSelectData, TOutput, QueryKey, InferCursor<TInput>>, 'queryKey' | (undefined extends InferCursor<TInput> ? 'initialPageParam' : never)>;
+export type MutationOptions<TInput, TOutput> = {
+    [P in keyof MutationObserverOptions<TOutput, DefaultError, TInput, unknown>]: MaybeDeepRef<MutationObserverOptions<TOutput, DefaultError, TInput, unknown>[P]>;
+} & {
+    shallow?: MaybeRef<boolean>;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,31 @@
+import type { Caller } from '@orpc/server';
+import type { IsEqual } from '@orpc/shared';
+import type { QueryKey } from '@tanstack/vue-query';
+import type { ComputedRef } from 'vue';
+import type { InfiniteOptions, MutationOptions, QueryOptions } from './types';
+/**
+ * Utils at procedure level
+ */
+export interface ProcedureUtils<TInput, TOutput> {
+    queryOptions: <U extends QueryOptions<TInput, TOutput, any>>(...options: [U] | (undefined extends TInput ? [] : never)) => IsEqual<U, QueryOptions<TInput, TOutput, any>> extends true ? {
+        queryKey: QueryKey;
+        queryFn: () => Promise<TOutput>;
+    } : Omit<{
+        queryKey: ComputedRef<QueryKey>;
+        queryFn: () => Promise<TOutput>;
+    }, keyof U> & U;
+    infiniteOptions: <U extends InfiniteOptions<TInput, TOutput, any>>(options: U) => Omit<{
+        queryKey: ComputedRef<QueryKey>;
+        queryFn: () => Promise<TOutput>;
+        initialPageParam: undefined;
+    }, keyof U> & U;
+    mutationOptions: <U extends MutationOptions<TInput, TOutput>>(options?: U) => IsEqual<U, MutationOptions<TInput, TOutput>> extends true ? {
+        mutationKey: QueryKey;
+        mutationFn: (input: TInput) => Promise<TOutput>;
+    } : Omit<{
+        mutationKey: QueryKey;
+        mutationFn: (input: TInput) => Promise<TOutput>;
+    }, keyof U> & U;
+}
+export declare function createProcedureUtils<TInput, TOutput>(client: Caller<TInput, TOutput>, path: string[]): ProcedureUtils<TInput, TOutput>;
+//# sourceMappingURL=utils-procedure.d.ts.map

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

@@ -0,0 +1,14 @@
+import type { RouterClient } from '@orpc/client';
+import type { ContractProcedure, ContractRouter, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { Lazy, Procedure, Router } from '@orpc/server';
+import { type GeneralUtils } from './utils-general';
+import { type ProcedureUtils } from './utils-procedure';
+export type RouterUtils<T extends Router<any> | ContractRouter> = {
+    [K in keyof T]: T[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> | Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput>> ? ProcedureUtils<SchemaInput<UInputSchema>, SchemaOutput<UOutputSchema, UFuncOutput>> & GeneralUtils<SchemaInput<UInputSchema>> : T[K] extends Router<any> | ContractRouter ? 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 Router<any> | ContractRouter>(client: RouterClient<T>, path?: string[]): RouterUtils<T>;
+//# sourceMappingURL=utils-router.d.ts.map

package/dist/src/utils.d.ts

@@ -0,0 +1,3 @@
+import type { MaybeDeepRef } from './types';
+export declare function deepUnref<T>(value: MaybeDeepRef<T>): T;
+//# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@orpc/vue-query",
+  "type": "module",
+  "version": "0.0.0-next.18dacf3",
+  "license": "MIT",
+  "homepage": "https://orpc.unnoq.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unnoq/orpc.git",
+    "directory": "packages/vue-query"
+  },
+  "keywords": [
+    "unnoq",
+    "orpc",
+    "vue",
+    "vue-query",
+    "tanstack"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./🔒/*": {
+      "types": "./dist/src/*.d.ts"
+    }
+  },
+  "files": [
+    "!**/*.map",
+    "!**/*.tsbuildinfo",
+    "dist"
+  ],
+  "peerDependencies": {
+    "@tanstack/vue-query": ">=5.50.0",
+    "vue": ">=3.3.0",
+    "@orpc/client": "0.0.0-next.18dacf3",
+    "@orpc/contract": "0.0.0-next.18dacf3",
+    "@orpc/server": "0.0.0-next.18dacf3"
+  },
+  "scripts": {
+    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build:watch": "pnpm run build --watch",
+    "type:check": "tsc -b"
+  }
+}