@orpc/pinia-colada 0.0.0

package/dist/index.mjs

@@ -0,0 +1,516 @@
+import { resolveBasePathMeta } from '@orpc/contract';
+import { sortPlugins, stringifyJSON, resolveMaybeOptionalOptions, intercept, isAsyncIteratorObject, toArray, bindMethods, getOrBind, get, isTypescriptObject } from '@orpc/shared';
+import { RPCJsonSerializer, RECURSIVE_CLIENT_UNWRAP_KEYS } from '@orpc/client';
+
+class CompositeRouterUtilsPlugin {
+  constructor(plugins = []) {
+    this.plugins = plugins;
+    this.plugins = sortPlugins(plugins);
+  }
+  name = "~composite";
+  init(options) {
+    for (const plugin of this.plugins) {
+      if (plugin.init) {
+        options = plugin.init(options);
+      }
+    }
+    return options;
+  }
+  initProcedureOptions(path, options) {
+    for (const plugin of this.plugins) {
+      if (plugin.initProcedureOptions) {
+        options = plugin.initProcedureOptions(path, options);
+      }
+    }
+    return options;
+  }
+}
+
+const serializer = new RPCJsonSerializer();
+function generateOperationKey(path, options = {}) {
+  return [
+    ...options.prefix !== void 0 ? [options.prefix] : [],
+    path,
+    {
+      ...options.input !== void 0 ? { input: serializer.serialize(options.input).json } : {},
+      ...options.type !== void 0 ? { type: options.type } : {},
+      ...options.fnOptions !== void 0 ? { fnOptions: options.fnOptions } : {}
+    }
+  ];
+}
+
+function liveQuery(queryFn) {
+  return async (context) => {
+    const { entry, signal } = context;
+    const stream = await queryFn(context);
+    let last;
+    for await (const chunk of stream) {
+      if (signal.aborted) {
+        throw signal.reason;
+      }
+      last = { chunk };
+      entry.state.value = { status: "success", data: chunk, error: null };
+    }
+    if (!last) {
+      throw new TypeError(
+        `Live query for ${stringifyJSON(entry.key)} did not yield any data. Ensure the query function returns an AsyncIterable with at least one chunk.`
+      );
+    }
+    return last.chunk;
+  };
+}
+
+class SharedUtils {
+  constructor(path, options) {
+    this.path = path;
+    this.options = options;
+  }
+  /**
+   * Generate a **partial matching** key for actions like revalidating queries, checking mutation status, etc.
+   *
+   * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
+   */
+  key(options = {}) {
+    return generateOperationKey(this.path, { ...options, prefix: this.options.prefix });
+  }
+}
+
+function serializableStreamedQuery(queryFn, { refetchMode = "reset", maxChunks = Number.POSITIVE_INFINITY } = {}) {
+  return async (context) => {
+    const { entry, signal } = context;
+    const previousData = entry.state.value.data;
+    const hasPreviousData = previousData !== void 0;
+    if (hasPreviousData && refetchMode === "reset") {
+      entry.state.value = { status: "pending", data: void 0, error: null };
+    }
+    const stream = await queryFn(context);
+    const shouldUpdateCacheDuringStream = !hasPreviousData || refetchMode !== "replace";
+    let result = hasPreviousData && refetchMode === "append" ? limitArraySize(previousData, maxChunks) : [];
+    if (shouldUpdateCacheDuringStream) {
+      entry.state.value = { status: "success", data: result, error: null };
+    }
+    for await (const chunk of stream) {
+      if (signal.aborted) {
+        throw signal.reason;
+      }
+      result = limitArraySize([...result, chunk], maxChunks);
+      if (shouldUpdateCacheDuringStream) {
+        entry.state.value = { status: "success", data: result, error: null };
+      }
+    }
+    return result;
+  };
+}
+function limitArraySize(items, maxSize) {
+  if (items.length <= maxSize) {
+    return items;
+  }
+  return items.slice(items.length - maxSize);
+}
+
+const OPERATION_CONTEXT_SYMBOL = Symbol.for("ORPC_PINIA_COLADA_OPERATION_CONTEXT");
+
+class ProcedureUtils extends SharedUtils {
+  /**
+   * Calling corresponding procedure client
+   *
+   * @see {@link https://orpc.dev/docs/integrations/pinia-colada#calling-procedure-clients Pinia Colada Calling Procedure Client Docs}
+   */
+  call;
+  constructor(path, client, options = {}) {
+    super(path, options);
+    this.call = client;
+  }
+  /**
+   * Generate a **full matching** key for useQuery/...
+   *
+   * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
+   */
+  queryKey(...rest) {
+    let optionsIn = resolveMaybeOptionalOptions(rest);
+    if (typeof this.options.queryKey === "function") {
+      optionsIn = this.options.queryKey(optionsIn);
+    } else if (this.options.queryKey) {
+      optionsIn = { ...this.options.queryKey, ...optionsIn };
+    }
+    const key = optionsIn.key ?? generateOperationKey(this.path, { prefix: this.options.prefix, type: "query", input: optionsIn.input });
+    return key;
+  }
+  /**
+   * Generate options used for useQuery/...
+   *
+   * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-options-utility Pinia Colada Query Options Utility Docs}
+   */
+  queryOptions(...rest) {
+    let optionsIn = resolveMaybeOptionalOptions(rest);
+    if (typeof this.options.queryOptions === "function") {
+      optionsIn = this.options.queryOptions(optionsIn);
+    } else if (this.options.queryOptions) {
+      optionsIn = { ...this.options.queryOptions, ...optionsIn };
+    }
+    const { input, context, key: _keyIn, query: queryIn, ...restOptions } = optionsIn;
+    const key = this.queryKey(optionsIn);
+    return {
+      ...restOptions,
+      key,
+      query: (fnContext) => {
+        return intercept(
+          this.options.queryInterceptors,
+          {
+            path: this.path,
+            context: {
+              [OPERATION_CONTEXT_SYMBOL]: {
+                key,
+                type: "query"
+              },
+              ...context
+            },
+            input,
+            fnContext
+          },
+          ({ context: context2, input: input2, fnContext: fnContext2 }) => {
+            if (queryIn) {
+              return queryIn(fnContext2);
+            }
+            return this.call(input2, { signal: fnContext2.signal, context: context2 });
+          }
+        );
+      }
+    };
+  }
+  /**
+   * Generate a **full matching** key for [Streamed Query Options](https://orpc.dev/docs/integrations/pinia-colada#streamed-query-options-utility).
+   *
+   * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
+   */
+  streamedKey(...rest) {
+    let optionsIn = resolveMaybeOptionalOptions(rest);
+    if (typeof this.options.streamedKey === "function") {
+      optionsIn = this.options.streamedKey(optionsIn);
+    } else if (this.options.streamedKey) {
+      optionsIn = { ...this.options.streamedKey, ...optionsIn };
+    }
+    const key = optionsIn.key ?? generateOperationKey(this.path, { prefix: this.options.prefix, type: "streamed", input: optionsIn.input, fnOptions: optionsIn.fnOptions });
+    return key;
+  }
+  /**
+   * Configure queries for [AsyncIteratorObject](https://orpc.dev/docs/async-iterator-object).
+   * The resulting data is an array of chunks, and each new chunk is appended as it arrives.
+   * Works with `useQuery` and any other API that accepts query options.
+   */
+  streamedOptions(...rest) {
+    let optionsIn = resolveMaybeOptionalOptions(rest);
+    if (typeof this.options.streamedOptions === "function") {
+      optionsIn = this.options.streamedOptions(optionsIn);
+    } else if (this.options.streamedOptions) {
+      optionsIn = { ...this.options.streamedOptions, ...optionsIn };
+    }
+    const { input, context, key: _keyIn, query: queryIn, fnOptions, ...restOptions } = optionsIn;
+    const key = this.streamedKey(optionsIn);
+    return {
+      ...restOptions,
+      key,
+      query: (fnContext) => {
+        return intercept(
+          this.options.streamedInterceptors,
+          {
+            path: this.path,
+            context: {
+              [OPERATION_CONTEXT_SYMBOL]: {
+                key,
+                type: "streamed"
+              },
+              ...context
+            },
+            input,
+            fnContext
+          },
+          ({ context: context2, input: input2, fnContext: fnContext2 }) => {
+            if (queryIn) {
+              return queryIn(fnContext2);
+            }
+            return serializableStreamedQuery(
+              async (queryContext) => {
+                const output = await this.call(input2, { signal: queryContext.signal, context: context2 });
+                if (!isAsyncIteratorObject(output)) {
+                  throw new Error("streamedQuery requires an AsyncIteratorObject output");
+                }
+                return output;
+              },
+              fnOptions
+            )(fnContext2);
+          }
+        );
+      }
+    };
+  }
+  /**
+   * Generate a **full matching** key for [Live Query Options](https://orpc.dev/docs/integrations/pinia-colada#live-query-options-utility).
+   *
+   * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
+   */
+  liveKey(...rest) {
+    let optionsIn = resolveMaybeOptionalOptions(rest);
+    if (typeof this.options.liveKey === "function") {
+      optionsIn = this.options.liveKey(optionsIn);
+    } else if (this.options.liveKey) {
+      optionsIn = { ...this.options.liveKey, ...optionsIn };
+    }
+    const key = optionsIn.key ?? generateOperationKey(this.path, { prefix: this.options.prefix, type: "live", input: optionsIn.input });
+    return key;
+  }
+  /**
+   * Configure live queries for [AsyncIteratorObject](https://orpc.dev/docs/async-iterator-object).
+   * Unlike `.streamedOptions` which accumulates chunks, live queries replace the entire result with each new chunk received.
+   * Works with `useQuery` and any other API that accepts query options.
+   */
+  liveOptions(...rest) {
+    let optionsIn = resolveMaybeOptionalOptions(rest);
+    if (typeof this.options.liveOptions === "function") {
+      optionsIn = this.options.liveOptions(optionsIn);
+    } else if (this.options.liveOptions) {
+      optionsIn = { ...this.options.liveOptions, ...optionsIn };
+    }
+    const { input, context, key: _keyIn, query: queryIn, ...restOptions } = optionsIn;
+    const key = this.liveKey(optionsIn);
+    return {
+      ...restOptions,
+      key,
+      query: (fnContext) => {
+        return intercept(
+          this.options.liveInterceptors,
+          {
+            path: this.path,
+            context: {
+              [OPERATION_CONTEXT_SYMBOL]: {
+                key,
+                type: "live"
+              },
+              ...context
+            },
+            input,
+            fnContext
+          },
+          ({ context: context2, input: input2, fnContext: fnContext2 }) => {
+            if (queryIn) {
+              return queryIn(fnContext2);
+            }
+            return liveQuery(async (queryContext) => {
+              const output = await this.call(input2, { signal: queryContext.signal, context: context2 });
+              if (!isAsyncIteratorObject(output)) {
+                throw new Error("liveQuery requires an AsyncIteratorObject output");
+              }
+              return output;
+            })(fnContext2);
+          }
+        );
+      }
+    };
+  }
+  /**
+   * Generate a **full matching** key for useInfiniteQuery/...
+   *
+   * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
+   */
+  infiniteKey(optionsIn) {
+    if (typeof this.options.infiniteKey === "function") {
+      optionsIn = this.options.infiniteKey(optionsIn);
+    } else if (this.options.infiniteKey) {
+      optionsIn = { ...this.options.infiniteKey, ...optionsIn };
+    }
+    const key = optionsIn.key ?? generateOperationKey(this.path, {
+      prefix: this.options.prefix,
+      type: "infinite",
+      input: optionsIn.input(
+        typeof optionsIn.initialPageParam === "function" ? optionsIn.initialPageParam() : optionsIn.initialPageParam
+      )
+    });
+    return key;
+  }
+  /**
+   * Generate options used for useInfiniteQuery/...
+   *
+   * @see {@link https://orpc.dev/docs/integrations/pinia-colada#infinite-query-options-utility Pinia Colada Infinite Query Options Utility Docs}
+   */
+  infiniteOptions(optionsIn) {
+    if (typeof this.options.infiniteOptions === "function") {
+      optionsIn = this.options.infiniteOptions(optionsIn);
+    } else if (this.options.infiniteOptions) {
+      optionsIn = { ...this.options.infiniteOptions, ...optionsIn };
+    }
+    const { input, context, key: _keyIn, query: queryIn, ...restOptions } = optionsIn;
+    const key = this.infiniteKey(optionsIn);
+    return {
+      ...restOptions,
+      key,
+      query: (fnContext) => {
+        return intercept(
+          this.options.infiniteInterceptors,
+          {
+            path: this.path,
+            context: {
+              [OPERATION_CONTEXT_SYMBOL]: {
+                key,
+                type: "infinite"
+              },
+              ...context
+            },
+            input: input(fnContext.pageParam),
+            fnContext
+          },
+          ({ context: context2, input: input2, fnContext: fnContext2 }) => {
+            if (queryIn) {
+              return queryIn(fnContext2);
+            }
+            return this.call(input2, { signal: fnContext2.signal, context: context2 });
+          }
+        );
+      }
+    };
+  }
+  /**
+   * Generate a **full matching** key for useMutation/...
+   *
+   * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
+   */
+  mutationKey(...rest) {
+    let optionsIn = resolveMaybeOptionalOptions(rest);
+    if (typeof this.options.mutationKey === "function") {
+      optionsIn = this.options.mutationKey(optionsIn);
+    } else if (this.options.mutationKey) {
+      optionsIn = { ...this.options.mutationKey, ...optionsIn };
+    }
+    const key = optionsIn.key ?? ((input) => generateOperationKey(this.path, { prefix: this.options.prefix, type: "mutation", input }));
+    return key;
+  }
+  /**
+   * Generate options used for useMutation/...
+   *
+   * @see {@link https://orpc.dev/docs/integrations/pinia-colada#mutation-options Pinia Colada Mutation Options Docs}
+   */
+  mutationOptions(...rest) {
+    let optionsIn = resolveMaybeOptionalOptions(rest);
+    if (typeof this.options.mutationOptions === "function") {
+      optionsIn = this.options.mutationOptions(optionsIn);
+    } else if (this.options.mutationOptions) {
+      optionsIn = { ...this.options.mutationOptions, ...optionsIn };
+    }
+    const { context, key: _keyIn, mutation: mutationIn, ...restOptions } = optionsIn;
+    const key = this.mutationKey(optionsIn);
+    return {
+      ...restOptions,
+      key,
+      mutation: (input, fnContext) => {
+        return intercept(
+          this.options.mutationInterceptors,
+          {
+            path: this.path,
+            context: {
+              [OPERATION_CONTEXT_SYMBOL]: {
+                key: typeof key === "function" ? key(input) : key,
+                type: "mutation"
+              },
+              ...context
+            },
+            input,
+            fnContext
+          },
+          ({ context: context2, input: input2, fnContext: fnContext2 }) => {
+            if (mutationIn) {
+              return mutationIn(input2, fnContext2);
+            }
+            return this.call(input2, { context: context2 });
+          }
+        );
+      }
+    };
+  }
+}
+
+function createRouterUtils(client, options = {}) {
+  const plugin = new CompositeRouterUtilsPlugin(options.plugins);
+  options = plugin.init(options);
+  return createRouterUtilsInternal(client, options, plugin);
+}
+function createRouterUtilsInternal(client, options, plugin) {
+  const path = toArray(options.path);
+  const utils = typeof client === "function" && (options.scoped === void 0 || isProcedureUtilsOptions(options.scoped)) ? bindMethods(new ProcedureUtils(
+    path,
+    client,
+    plugin.initProcedureOptions(path, {
+      prefix: options.prefix,
+      ...options.scoped,
+      queryInterceptors: [...toArray(options.queryInterceptors), ...toArray(options.scoped?.queryInterceptors)],
+      streamedInterceptors: [...toArray(options.streamedInterceptors), ...toArray(options.scoped?.streamedInterceptors)],
+      liveInterceptors: [...toArray(options.liveInterceptors), ...toArray(options.scoped?.liveInterceptors)],
+      infiniteInterceptors: [...toArray(options.infiniteInterceptors), ...toArray(options.scoped?.infiniteInterceptors)],
+      mutationInterceptors: [...toArray(options.mutationInterceptors), ...toArray(options.scoped?.mutationInterceptors)]
+    })
+  )) : bindMethods(new SharedUtils(path, options));
+  const recursive = new Proxy(utils, {
+    get(target, prop) {
+      const value = getOrBind(target, prop);
+      const nextClient = get(client, [prop]);
+      if (typeof prop !== "string" || RECURSIVE_CLIENT_UNWRAP_KEYS.has(prop) || !isTypescriptObject(nextClient)) {
+        return value;
+      }
+      const nextUtils = createRouterUtilsInternal(nextClient, {
+        ...options,
+        path: [...path, prop],
+        scoped: get(options.scoped, [prop])
+      }, plugin);
+      if (typeof value !== "function") {
+        return nextUtils;
+      }
+      return new Proxy(value, {
+        get(target2, prop2) {
+          if (typeof prop2 !== "string" || RECURSIVE_CLIENT_UNWRAP_KEYS.has(prop2)) {
+            return getOrBind(target2, prop2);
+          }
+          return getOrBind(nextUtils, prop2);
+        }
+      });
+    }
+  });
+  return recursive;
+}
+function isProcedureUtilsOptions(value) {
+  if (!isTypescriptObject(value)) {
+    return false;
+  }
+  if (value.queryInterceptors !== void 0 && !Array.isArray(value.queryInterceptors)) {
+    return false;
+  }
+  if (value.streamedInterceptors !== void 0 && !Array.isArray(value.streamedInterceptors)) {
+    return false;
+  }
+  if (value.liveInterceptors !== void 0 && !Array.isArray(value.liveInterceptors)) {
+    return false;
+  }
+  if (value.infiniteInterceptors !== void 0 && !Array.isArray(value.infiniteInterceptors)) {
+    return false;
+  }
+  if (value.mutationInterceptors !== void 0 && !Array.isArray(value.mutationInterceptors)) {
+    return false;
+  }
+  return true;
+}
+
+function createContractUtilsFactory(clientFactory, options) {
+  const factory = (contract) => {
+    const client = clientFactory(contract);
+    const path = resolveBasePathMeta(contract);
+    if (path === void 0) {
+      throw new TypeError(
+        "ContractUtilsFactory: procedure contract must define `meta.path` that matches its path in the root router contract."
+      );
+    }
+    return createRouterUtils(client, { ...options, path, scoped: get(options.scoped, path) });
+  };
+  return factory;
+}
+function createContractJsonifiedUtilsFactory(clientFactory, options) {
+  return createContractUtilsFactory(clientFactory, options);
+}
+
+export { CompositeRouterUtilsPlugin, OPERATION_CONTEXT_SYMBOL, OPERATION_CONTEXT_SYMBOL as PINIA_COLADA_OPERATION_CONTEXT_SYMBOL, ProcedureUtils, SharedUtils, createContractJsonifiedUtilsFactory, createContractUtilsFactory, createRouterUtils as createPiniaColadaUtils, createRouterUtils, generateOperationKey, liveQuery, serializableStreamedQuery };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@orpc/pinia-colada",
+  "type": "module",
+  "version": "0.0.0",
+  "license": "MIT",
+  "homepage": "https://orpc.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/middleapi/orpc.git",
+    "directory": "packages/pinia-colada"
+  },
+  "keywords": [
+    "orpc",
+    "vue",
+    "pinia",
+    "pinia-colada"
+  ],
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@pinia/colada": ">=1.0.0",
+    "vue": ">=3.5.17"
+  },
+  "dependencies": {
+    "@orpc/client": "*",
+    "@orpc/contract": "*",
+    "@orpc/openapi": "*",
+    "@orpc/shared": "*"
+  },
+  "devDependencies": {
+    "@pinia/colada": "^1.4.2",
+    "@vue/test-utils": "^2.4.11",
+    "pinia": "^4.0.2",
+    "vue": "^3.5.38",
+    "zod": "^4.4.3"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "type:check": "tsc -b"
+  }
+}