@orpc/tanstack-query 1.14.6 → 2.0.0-beta.2

package/dist/index.mjs

@@ -1,4 +1,6 @@
-import { stringifyJSON, isAsyncIteratorObject, toArray, get } from '@orpc/shared';
+import { getPathMeta } from '@orpc/contract';
+import { sortPlugins, stringifyJSON, resolveMaybeOptionalOptions, intercept, toArray, isAsyncIteratorObject, bindMethods, getOrBind, get, isTypescriptObject } from '@orpc/shared';
+import { RECURSIVE_CLIENT_UNWRAP_KEYS } from '@orpc/client';
 import { skipToken } from '@tanstack/query-core';
 
 function generateOperationKey(path, state = {}) {
@@ -9,27 +11,41 @@ function generateOperationKey(path, state = {}) {
   }];
 }
 
-function createGeneralUtils(path) {
-  return {
-    key(options) {
-      return generateOperationKey(path, options);
+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;
+  }
 }
 
-function experimental_liveQuery(queryFn) {
+function liveQuery(queryFn) {
   return async (context) => {
     const stream = await queryFn(context);
     let last;
     for await (const chunk of stream) {
-      if (context.signal.aborted) {
-        throw context.signal.reason;
-      }
+      context.signal?.throwIfAborted();
       last = { chunk };
       context.client.setQueryData(context.queryKey, chunk);
     }
     if (!last) {
-      throw new Error(
+      throw new TypeError(
         `Live query for ${stringifyJSON(context.queryKey)} did not yield any data. Ensure the query function returns an AsyncIterable with at least one chunk.`
       );
     }
@@ -37,7 +53,7 @@ function experimental_liveQuery(queryFn) {
   };
 }
 
-function experimental_serializableStreamedQuery(queryFn, { refetchMode = "reset", maxChunks = Number.POSITIVE_INFINITY } = {}) {
+function serializableStreamedQuery(queryFn, { refetchMode = "reset", maxChunks = Number.POSITIVE_INFINITY } = {}) {
   return async (context) => {
     const query = context.client.getQueryCache().find({ queryKey: context.queryKey, exact: true });
     const hasPreviousData = !!query && query.state.data !== void 0;
@@ -93,199 +109,425 @@ function limitArraySize(items, maxSize) {
   return items.slice(items.length - maxSize);
 }
 
-const OPERATION_CONTEXT_SYMBOL = Symbol("ORPC_OPERATION_CONTEXT");
+const OPERATION_CONTEXT_SYMBOL = Symbol.for("ORPC_TANSTACK_QUERY_OPERATION_CONTEXT");
 
-function createProcedureUtils(client, options) {
-  const utils = {
-    call: client,
-    queryKey(...[optionsIn = {}]) {
-      optionsIn = { ...options.experimental_defaults?.queryKey, ...optionsIn };
-      const queryKey = optionsIn.queryKey ?? generateOperationKey(options.path, { type: "query", input: optionsIn.input });
-      return queryKey;
-    },
-    queryOptions(...[optionsIn = {}]) {
-      optionsIn = { ...options.experimental_defaults?.queryOptions, ...optionsIn };
-      const queryKey = utils.queryKey(optionsIn);
-      return {
-        queryFn: ({ signal }) => {
-          if (optionsIn.input === skipToken) {
-            throw new Error("queryFn should not be called with skipToken used as input");
-          }
-          return client(optionsIn.input, {
-            signal,
+class ProcedureUtils {
+  constructor(path, client, options = {}) {
+    this.path = path;
+    this.options = options;
+    this.call = client;
+  }
+  /**
+   * Calling corresponding procedure client
+   */
+  call;
+  /**
+   * Generate a **full matching** key for [Query Options](https://orpc.dev/docs/integrations/tanstack-query#query-options).
+   */
+  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 queryKey = optionsIn.queryKey ?? generateOperationKey(this.path, { type: "query", input: optionsIn.input });
+    return queryKey;
+  }
+  /**
+   * Generate options used for useQuery/useSuspenseQuery/prefetchQuery/...
+   */
+  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 queryKey = this.queryKey(optionsIn);
+    return {
+      ...optionsIn,
+      queryKey,
+      queryFn: (fnContext) => {
+        return intercept(
+          this.options.queryInterceptors,
+          {
+            path: this.path,
             context: {
               [OPERATION_CONTEXT_SYMBOL]: {
                 key: queryKey,
                 type: "query"
               },
               ...optionsIn.context
+            },
+            input: optionsIn.input,
+            fnContext
+          },
+          ({ context, input, fnContext: fnContext2 }) => {
+            if (input === skipToken || optionsIn.queryFn === skipToken) {
+              throw new Error("queryFn should not be called when skipToken used for skipping");
             }
-          });
-        },
-        ...optionsIn.input === skipToken ? { enabled: false } : {},
-        ...optionsIn,
-        queryKey
-      };
-    },
-    experimental_streamedKey(...[optionsIn = {}]) {
-      optionsIn = { ...options.experimental_defaults?.experimental_streamedKey, ...optionsIn };
-      const queryKey = optionsIn.queryKey ?? generateOperationKey(options.path, { type: "streamed", input: optionsIn.input, fnOptions: optionsIn.queryFnOptions });
-      return queryKey;
-    },
-    experimental_streamedOptions(...[optionsIn = {}]) {
-      optionsIn = { ...options.experimental_defaults?.experimental_streamedOptions, ...optionsIn };
-      const queryKey = utils.experimental_streamedKey(optionsIn);
-      return {
-        queryFn: experimental_serializableStreamedQuery(
-          async ({ signal }) => {
-            if (optionsIn.input === skipToken) {
-              throw new Error("queryFn should not be called with skipToken used as input");
+            if (optionsIn.queryFn) {
+              return optionsIn.queryFn(fnContext2);
             }
-            const output = await client(optionsIn.input, {
-              signal,
-              context: {
-                [OPERATION_CONTEXT_SYMBOL]: {
-                  key: queryKey,
-                  type: "streamed"
-                },
-                ...optionsIn.context
-              }
-            });
-            if (!isAsyncIteratorObject(output)) {
-              throw new Error("streamedQuery requires an event iterator output");
-            }
-            return output;
+            return this.call(input, { signal: fnContext2.signal, context });
+          }
+        );
+      },
+      ...optionsIn.input === skipToken || optionsIn.queryFn === skipToken ? { enabled: false } : {}
+    };
+  }
+  /**
+   * Generate a **full matching** key for [Streamed Query Options](https://orpc.dev/docs/integrations/tanstack-query#streamed-query-options).
+   */
+  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 queryKey = optionsIn.queryKey ?? generateOperationKey(this.path, { type: "streamed", input: optionsIn.input, fnOptions: optionsIn.queryFnOptions });
+    return queryKey;
+  }
+  /**
+   * Configure queries for [Event Iterator](https://orpc.dev/docs/event-iterator).
+   * This is built on [TanStack Query streamedQuery](https://tanstack.com/query/latest/docs/reference/streamedQuery)
+   * and works with hooks like `useQuery`, `useSuspenseQuery`, or `prefetchQuery`.
+   */
+  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 queryKey = this.streamedKey(optionsIn);
+    return {
+      ...optionsIn,
+      queryKey,
+      queryFn: (fnContext) => {
+        return intercept(
+          toArray(this.options.streamedInterceptors),
+          {
+            path: this.path,
+            context: {
+              [OPERATION_CONTEXT_SYMBOL]: {
+                key: queryKey,
+                type: "streamed"
+              },
+              ...optionsIn.context
+            },
+            input: optionsIn.input,
+            fnContext
           },
-          optionsIn.queryFnOptions
-        ),
-        ...optionsIn.input === skipToken ? { enabled: false } : {},
-        ...optionsIn,
-        queryKey
-      };
-    },
-    experimental_liveKey(...[optionsIn = {}]) {
-      optionsIn = { ...options.experimental_defaults?.experimental_liveKey, ...optionsIn };
-      const queryKey = optionsIn.queryKey ?? generateOperationKey(options.path, { type: "live", input: optionsIn.input });
-      return queryKey;
-    },
-    experimental_liveOptions(...[optionsIn = {}]) {
-      optionsIn = { ...options.experimental_defaults?.experimental_liveOptions, ...optionsIn };
-      const queryKey = utils.experimental_liveKey(optionsIn);
-      return {
-        queryFn: experimental_liveQuery(async ({ signal }) => {
-          if (optionsIn.input === skipToken) {
-            throw new Error("queryFn should not be called with skipToken used as input");
+          ({ context, fnContext: fnContext2, input }) => {
+            if (input === skipToken || optionsIn.queryFn === skipToken) {
+              throw new Error("queryFn should not be called when skipToken used for skipping");
+            }
+            if (optionsIn.queryFn) {
+              return optionsIn.queryFn(fnContext2);
+            }
+            return serializableStreamedQuery(
+              async (queryContext) => {
+                const output = await this.call(input, { signal: queryContext.signal, context });
+                if (!isAsyncIteratorObject(output)) {
+                  throw new Error("streamedQuery requires an event iterator output");
+                }
+                return output;
+              },
+              optionsIn.queryFnOptions
+            )(fnContext2);
           }
-          const output = await client(optionsIn.input, {
-            signal,
+        );
+      },
+      ...optionsIn.input === skipToken || optionsIn.queryFn === skipToken ? { enabled: false } : {}
+    };
+  }
+  /**
+   * Generate a **full matching** key for [Live Query Options](https://orpc.dev/docs/integrations/tanstack-query#live-query-options).
+   */
+  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 queryKey = optionsIn.queryKey ?? generateOperationKey(this.path, { type: "live", input: optionsIn.input });
+    return queryKey;
+  }
+  /**
+   * Configure live queries for [Event Iterator](https://orpc.dev/docs/event-iterator).
+   * Unlike `.streamedOptions` which accumulates chunks, live queries replace the entire result with each new chunk received.
+   * Works with hooks like `useQuery`, `useSuspenseQuery`, or `prefetchQuery`.
+   */
+  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 queryKey = this.liveKey(optionsIn);
+    return {
+      ...optionsIn,
+      queryKey,
+      queryFn: (fnContext) => {
+        return intercept(
+          toArray(this.options.liveInterceptors),
+          {
+            path: this.path,
             context: {
               [OPERATION_CONTEXT_SYMBOL]: {
                 key: queryKey,
                 type: "live"
               },
               ...optionsIn.context
+            },
+            input: optionsIn.input,
+            fnContext
+          },
+          ({ fnContext: fnContext2, input, context }) => {
+            if (input === skipToken || optionsIn.queryFn === skipToken) {
+              throw new Error("queryFn should not be called when skipToken used for skipping");
             }
-          });
-          if (!isAsyncIteratorObject(output)) {
-            throw new Error("liveQuery requires an event iterator output");
-          }
-          return output;
-        }),
-        ...optionsIn.input === skipToken ? { enabled: false } : {},
-        ...optionsIn,
-        queryKey
-      };
-    },
-    infiniteKey(optionsIn) {
-      optionsIn = { ...options.experimental_defaults?.infiniteKey, ...optionsIn };
-      const queryKey = optionsIn.queryKey ?? generateOperationKey(options.path, {
-        type: "infinite",
-        input: optionsIn.input === skipToken ? skipToken : optionsIn.input(optionsIn.initialPageParam)
-      });
-      return queryKey;
-    },
-    infiniteOptions(optionsIn) {
-      optionsIn = { ...options.experimental_defaults?.infiniteOptions, ...optionsIn };
-      const queryKey = utils.infiniteKey(optionsIn);
-      return {
-        queryFn: ({ pageParam, signal }) => {
-          if (optionsIn.input === skipToken) {
-            throw new Error("queryFn should not be called with skipToken used as input");
+            if (optionsIn.queryFn) {
+              return optionsIn.queryFn(fnContext2);
+            }
+            return liveQuery(async (queryContext) => {
+              const output = await this.call(input, {
+                signal: queryContext.signal,
+                context
+              });
+              if (!isAsyncIteratorObject(output)) {
+                throw new Error("liveQuery requires an event iterator output");
+              }
+              return output;
+            })(fnContext2);
           }
-          return client(optionsIn.input(pageParam), {
-            signal,
+        );
+      },
+      ...optionsIn.input === skipToken || optionsIn.queryFn === skipToken ? { enabled: false } : {}
+    };
+  }
+  /**
+   * Generate a **full matching** key for [Infinite Query Options](https://orpc.dev/docs/integrations/tanstack-query#infinite-query-options).
+   */
+  infiniteKey(optionsIn) {
+    if (typeof this.options.infiniteKey === "function") {
+      optionsIn = this.options.infiniteKey(optionsIn);
+    } else if (this.options.infiniteKey) {
+      optionsIn = { ...this.options.infiniteKey, ...optionsIn };
+    }
+    const queryKey = optionsIn.queryKey ?? generateOperationKey(this.path, {
+      type: "infinite",
+      input: optionsIn.input === skipToken ? skipToken : optionsIn.input(optionsIn.initialPageParam)
+    });
+    return queryKey;
+  }
+  /**
+   * Generate options used for useInfiniteQuery/useSuspenseInfiniteQuery/prefetchInfiniteQuery/...
+   */
+  infiniteOptions(optionsIn) {
+    if (typeof this.options.infiniteOptions === "function") {
+      optionsIn = this.options.infiniteOptions(optionsIn);
+    } else if (this.options.infiniteOptions) {
+      optionsIn = { ...this.options.infiniteOptions, ...optionsIn };
+    }
+    const queryKey = this.infiniteKey(optionsIn);
+    return {
+      ...optionsIn,
+      queryKey,
+      queryFn: (fnContext) => {
+        return intercept(
+          toArray(this.options.infiniteInterceptors),
+          {
+            path: this.path,
             context: {
               [OPERATION_CONTEXT_SYMBOL]: {
                 key: queryKey,
                 type: "infinite"
               },
               ...optionsIn.context
-            }
-          });
-        },
-        ...optionsIn.input === skipToken ? { enabled: false } : {},
-        ...optionsIn,
-        queryKey
-      };
-    },
-    mutationKey(...[optionsIn = {}]) {
-      optionsIn = { ...options.experimental_defaults?.mutationKey, ...optionsIn };
-      const mutationKey = optionsIn.mutationKey ?? generateOperationKey(options.path, { type: "mutation" });
-      return mutationKey;
-    },
-    mutationOptions(...[optionsIn = {}]) {
-      optionsIn = { ...options.experimental_defaults?.mutationOptions, ...optionsIn };
-      const mutationKey = utils.mutationKey(optionsIn);
-      return {
-        mutationFn: (input) => client(input, {
-          context: {
-            [OPERATION_CONTEXT_SYMBOL]: {
-              key: mutationKey,
-              type: "mutation"
             },
-            ...optionsIn.context
+            input: optionsIn.input === skipToken ? skipToken : optionsIn.input(fnContext.pageParam),
+            fnContext
+          },
+          ({ context, input, fnContext: fnContext2 }) => {
+            if (input === skipToken || optionsIn.queryFn === skipToken) {
+              throw new Error("queryFn should not be called when skipToken used for skipping");
+            }
+            if (optionsIn.queryFn) {
+              return optionsIn.queryFn(fnContext2);
+            }
+            return this.call(input, { signal: fnContext2.signal, context });
           }
-        }),
-        ...optionsIn,
-        mutationKey
-      };
+        );
+      },
+      ...optionsIn.input === skipToken || optionsIn.queryFn === skipToken ? { enabled: false } : {}
+    };
+  }
+  /**
+   * Generate a **full matching** key for [Mutation Options](https://orpc.dev/docs/integrations/tanstack-query#mutation-options).
+   */
+  mutationKey(optionsIn = {}) {
+    if (typeof this.options.mutationKey === "function") {
+      optionsIn = this.options.mutationKey(optionsIn);
+    } else if (this.options.mutationKey) {
+      optionsIn = { ...this.options.mutationKey, ...optionsIn };
     }
-  };
-  return utils;
+    const mutationKey = optionsIn.mutationKey ?? generateOperationKey(this.path, { type: "mutation" });
+    return mutationKey;
+  }
+  /**
+   * Generate options used for useMutation/...
+   */
+  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 mutationKey = this.mutationKey(optionsIn);
+    return {
+      ...optionsIn,
+      mutationKey,
+      mutationFn: (input, fnContext) => {
+        return intercept(
+          toArray(this.options.mutationInterceptors),
+          {
+            path: this.path,
+            context: {
+              [OPERATION_CONTEXT_SYMBOL]: {
+                key: mutationKey,
+                type: "mutation"
+              },
+              ...optionsIn.context
+            },
+            fnContext,
+            input
+          },
+          ({ input: input2, fnContext: fnContext2, context }) => {
+            if (optionsIn.mutationFn) {
+              return optionsIn.mutationFn(input2, fnContext2);
+            }
+            return this.call(input2, { context });
+          }
+        );
+      }
+    };
+  }
 }
 
+class SharedRouterUtils {
+  constructor(path) {
+    this.path = path;
+  }
+  /**
+   * Generate a **partial matching** key for actions like revalidating queries, checking mutation status, etc.
+   */
+  key(options = {}) {
+    return generateOperationKey(this.path, options);
+  }
+}
 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 generalUtils = createGeneralUtils(path);
-  const procedureUtils = createProcedureUtils(client, {
+  const sharedUtils = bindMethods(new SharedRouterUtils(path));
+  const procedureUtils = typeof client === "function" && (options.scoped === void 0 || isProcedureUtilsOptions(options.scoped)) ? bindMethods(new ProcedureUtils(
     path,
-    experimental_defaults: options.experimental_defaults
-  });
+    client,
+    plugin.initProcedureOptions(path, {
+      ...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)]
+    })
+  )) : void 0;
   const recursive = new Proxy({
-    ...generalUtils,
+    ...sharedUtils,
     ...procedureUtils
   }, {
     get(target, prop) {
-      const value = Reflect.get(target, prop);
-      if (typeof prop !== "string") {
+      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 = createRouterUtils(client[prop], {
+      const nextUtils = createRouterUtilsInternal(nextClient, {
         ...options,
         path: [...path, prop],
-        experimental_defaults: get(options.experimental_defaults, [prop])
-      });
+        scoped: get(options.scoped, [prop])
+      }, plugin);
       if (typeof value !== "function") {
         return nextUtils;
       }
       return new Proxy(value, {
-        get(_, prop2) {
-          return Reflect.get(nextUtils, prop2);
+        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(caller, options) {
+  return (procedure) => {
+    const path = getPathMeta(procedure);
+    if (!path) {
+      throw new TypeError(
+        "ContractUtilsFactory: procedure contract must define `meta.path` that matches its path in the root router contract."
+      );
+    }
+    const scoped = get(options.scoped, path);
+    if (scoped !== void 0 && (scoped === null || typeof scoped !== "object")) {
+      throw new TypeError(
+        `ContractUtilsFactory: "scoped" at path "${path.join(".")}" must be an object or undefined, got "${scoped}".`
+      );
+    }
+    const client = (...rest) => caller(procedure, ...rest);
+    return createRouterUtils(client, {
+      ...options,
+      scoped,
+      path: [...toArray(options.path), ...path]
+    });
+  };
+}
+function createContractJsonifiedUtilsFactory(caller, options) {
+  return createContractUtilsFactory(caller, options);
+}
 
-export { OPERATION_CONTEXT_SYMBOL, OPERATION_CONTEXT_SYMBOL as TANSTACK_QUERY_OPERATION_CONTEXT_SYMBOL, createGeneralUtils, createProcedureUtils, createRouterUtils, createRouterUtils as createTanstackQueryUtils, experimental_serializableStreamedQuery, generateOperationKey };
+export { OPERATION_CONTEXT_SYMBOL, ProcedureUtils, SharedRouterUtils, OPERATION_CONTEXT_SYMBOL as TANSTACK_QUERY_OPERATION_CONTEXT_SYMBOL, createContractJsonifiedUtilsFactory, createContractUtilsFactory, createRouterUtils, createRouterUtils as createTanstackQueryUtils, generateOperationKey, serializableStreamedQuery };