@orpc/vue-colada 0.21.0

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,96 @@
+// src/key.ts
+import { SuperJSON } from "@orpc/server/fetch";
+function buildKey(path, options) {
+  return [
+    "__ORPC__",
+    ...path,
+    ...options?.input !== void 0 ? [{ input: JSON.stringify(SuperJSON.serialize(options.input)) }] : []
+  ];
+}
+
+// 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 {
+        key: computed(() => buildKey(path, { input: deepUnref(input) })),
+        query: ({ signal }) => client(deepUnref(input), { signal, context: deepUnref(options?.context) }),
+        ...options
+      };
+    },
+    mutationOptions(...[options]) {
+      return {
+        key: (input) => buildKey(path, { input }),
+        mutation: (input, _) => client(input, { context: deepUnref(options?.context) }),
+        ...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 createORPCVueColadaUtils = createRouterUtils;
+export {
+  buildKey,
+  createGeneralUtils,
+  createORPCVueColadaUtils,
+  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 createORPCVueColadaUtils: typeof createRouterUtils;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/key.d.ts

@@ -0,0 +1,6 @@
+import type { EntryKey } from '@pinia/colada';
+export interface BuildKeyOptions<TInput> {
+    input?: TInput;
+}
+export declare function buildKey<TInput>(path: string[], options?: BuildKeyOptions<TInput>): EntryKey;
+//# sourceMappingURL=key.d.ts.map

package/dist/src/types.d.ts

@@ -0,0 +1,25 @@
+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]>;
+} : 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>;
+} : {
+    input: MaybeDeepRef<TInput>;
+}) & (undefined extends TClientContext ? {
+    context?: MaybeDeepRef<TClientContext>;
+} : {
+    context: MaybeDeepRef<TClientContext>;
+}) & SetOptional<UseQueryOptions<TOutput>, 'key' | 'query'>;
+export type MutationOptions<TInput, TOutput, TClientContext> = (undefined extends TClientContext ? {
+    context?: MaybeDeepRef<TClientContext>;
+} : {
+    context: MaybeDeepRef<TClientContext>;
+}) & SetOptional<UseMutationOptions<TOutput, TInput>, 'mutation'>;
+//# sourceMappingURL=types.d.ts.map

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

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

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

package/dist/src/utils.d.ts

@@ -0,0 +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]>;
+} : T;
+export declare function deepUnref<T>(value: T): DeepUnref<T>;
+//# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@orpc/vue-colada",
+  "type": "module",
+  "version": "0.21.0",
+  "license": "MIT",
+  "homepage": "https://orpc.unnoq.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unnoq/orpc.git",
+    "directory": "packages/vue-colada"
+  },
+  "keywords": [
+    "unnoq",
+    "orpc",
+    "vue",
+    "vue-colada",
+    "pinia-colada",
+    "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": {
+    "@pinia/colada": ">=0.13.1",
+    "vue": ">=3.3.0",
+    "@orpc/client": "0.21.0",
+    "@orpc/contract": "0.21.0",
+    "@orpc/server": "0.21.0"
+  },
+  "dependencies": {
+    "@orpc/server": "0.21.0"
+  },
+  "devDependencies": {
+    "@pinia/colada": "^0.13.1",
+    "@vue/test-utils": "^2.4.6",
+    "pinia": "^2.3.0"
+  },
+  "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"
+  }
+}