eden2query 0.3.2 → 0.3.4

package/README.md

@@ -67,6 +67,56 @@ const queryClient = new QueryClient();
 queryClient.prefetchQuery(getOptions);
 ```
 
+### Hook builders: `createTreatyQueryHook` / `createTreatyMutationHook`
+
+Create reusable, pre-configured hooks for a Treaty endpoint. The second parameter is **`useOptions`**: either a static options object or a **function** that returns options (so you can use React hooks like `useQueryClient()` inside when the hook runs).
+
+**Query hook** — pass the Treaty GET thunk and `useOptions` (object or function):
+
+```ts
+const useResource = createTreatyQueryHook(
+  () => client.api.resource.get({ query: { q: "hello" } }),
+  { queryKey: ["resource"] },
+);
+
+// In a component
+const { data } = useResource(); // or useResource({ refetchInterval: 1000 })
+```
+
+**Mutation hook** — pass the Treaty mutation and optional `useOptions`. Use a function when you need React hooks (e.g. for invalidation):
+
+```ts
+// Static useOptions
+const usePostResource = createTreatyMutationHook(
+  (vars: { body: { name: string } }) => client.api.resource.post(vars.body),
+  { onSuccess: () => console.log("Success") },
+);
+
+// useOptions as function — use React hooks inside (e.g. useQueryClient)
+const usePostResourceWithInvalidation = createTreatyMutationHook(
+  (vars: { body: { name: string } }) => client.api.resource.post(vars.body),
+  () => {
+    const queryClient = useQueryClient();
+    return {
+      onSettled() {
+        queryClient.invalidateQueries({ queryKey: ["resource"] });
+      },
+    };
+  },
+);
+
+// In a component
+const postMutation = usePostResource();
+postMutation.mutate({ body: { name: "World" } });
+
+const postWithInvalidation = usePostResourceWithInvalidation({
+  onSuccess: () => console.log("Success"),
+});
+postWithInvalidation.mutate({ body: { name: "World" } });
+```
+
+Hooks accept the same options as `useQuery` / `useMutation`; call-time options are merged with the base options from `useOptions`.
+
 ## API
 
 **`treatyQueryOptions(fn, queryOptions)`** — wraps a Treaty GET call into `queryOptions`. `fn` is a **thunk** (zero-argument function) that calls the Treaty GET, e.g. `() => client.api.resource.get({ query: { ... } })`. The second argument accepts all `queryOptions` fields except `queryFn`. Extracts `data` from the response and throws on `error`.
@@ -78,6 +128,10 @@ queryClient.prefetchQuery(getOptions);
 
 The optional second argument accepts all `mutationOptions` fields except `mutationFn` (e.g. `onSuccess`, `onSettled`, `onMutate`).
 
+**`createTreatyQueryHook(fn, useOptions)`** — returns a hook that wraps `useQuery` with the given Treaty GET thunk. **`useOptions`** is either a query options object (e.g. `{ queryKey: [...] }`) or a function that returns options; the function is called when the hook runs, so you can use React hooks (e.g. `useQueryClient()`) inside it. The returned hook accepts the same options as `useQuery`; call-time options are merged with the base options.
+
+**`createTreatyMutationHook(fn, useOptions?)`** — returns a hook that wraps `useMutation` with the given Treaty mutation. Same fn shapes as `treatyMutationOptions` (no-arg or with variables). **`useOptions`** is optional; it can be a mutation options object or a function that returns options (so you can use `useQueryClient()` etc. for invalidation). The returned hook accepts the same options as `useMutation`.
+
 **`InferTreatyQueryOptions<T>`** — full `UseQueryOptions` type for a given Treaty query.
 
 **`InferTreatyMutationOptions<TVariables, TResponse>`** — full `UseMutationOptions` type for a given Treaty mutation.

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Treaty } from "@elysiajs/eden";
-import { UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
+import { UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
 type TreatyResponse = Record<number, unknown>;
 type TreatyFunctionWithoutParams<TResponse extends TreatyResponse = TreatyResponse> = () => Promise<Treaty.TreatyResponse<TResponse>>;
 type TreatyFunctionWithParams<
@@ -12,11 +12,27 @@ type TreatyMutationOptions<
 	TVariables,
 	TResponse extends TreatyResponse
 > = UseMutationOptions<TreatyData<TResponse>, TreatyError<TResponse>, TVariables>;
+type UseTreatyMutationResult<
+	TVariables,
+	TResponse extends TreatyResponse
+> = (UseMutationResult<TreatyData<TResponse>, TreatyError<TResponse>, TVariables>);
+type UseTreatyQueryResult<TResponse extends TreatyResponse> = (UseQueryResult<TreatyData<TResponse>, TreatyError<TResponse>>);
 type TreatyQueryOptions<TResponse extends Record<number, unknown>> = UseQueryOptions<TreatyData<TResponse>, TreatyError<TResponse>>;
+type UseTreatyMutationHook<
+	TVariables,
+	TResponse extends TreatyResponse
+> = ((options: Partial<Omit<TreatyMutationOptions<TVariables, TResponse>, "mutationFn">>) => UseTreatyMutationResult<TVariables, TResponse>);
+type UseTreatyQueryHook<TResponse extends TreatyResponse> = ((options: Partial<Omit<TreatyQueryOptions<TResponse>, "queryFn">>) => UseTreatyQueryResult<TResponse>);
 declare function treatyMutationOptions<TResponse extends TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, options?: Omit<TreatyMutationOptions<void, TResponse>, "mutationFn">): TreatyMutationOptions<void, TResponse>;
 declare function treatyMutationOptions<
 	TVariables,
 	TResponse extends TreatyResponse
 >(fn: TreatyFunctionWithParams<TVariables, TResponse>, options?: Omit<TreatyMutationOptions<TVariables, TResponse>, "mutationFn">): TreatyMutationOptions<TVariables, TResponse>;
 declare function treatyQueryOptions<TResponse extends TreatyResponse = TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, options: Omit<TreatyQueryOptions<TResponse>, "queryFn">): TreatyQueryOptions<TResponse>;
-export { treatyQueryOptions, treatyMutationOptions, TreatyQueryOptions, TreatyMutationOptions, TreatyError, TreatyData };
+declare function createTreatyMutationHook<TResponse extends TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, useOptions?: (Omit<TreatyMutationOptions<void, TResponse>, "mutationFn"> | (() => Omit<TreatyMutationOptions<void, TResponse>, "mutationFn">))): UseTreatyMutationHook<void, TResponse>;
+declare function createTreatyMutationHook<
+	TVariables,
+	TResponse extends TreatyResponse
+>(fn: TreatyFunctionWithParams<TVariables, TResponse>, useOptions?: (Omit<TreatyMutationOptions<TVariables, TResponse>, "mutationFn"> | (() => Omit<TreatyMutationOptions<TVariables, TResponse>, "mutationFn">))): UseTreatyMutationHook<TVariables, TResponse>;
+declare function createTreatyQueryHook<TResponse extends TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, useOptions: (Omit<TreatyQueryOptions<TResponse>, "queryFn"> | (() => Omit<TreatyQueryOptions<TResponse>, "queryFn">))): UseTreatyQueryHook<TResponse>;
+export { treatyQueryOptions, treatyMutationOptions, createTreatyQueryHook, createTreatyMutationHook, UseTreatyQueryHook, UseTreatyMutationHook, TreatyQueryOptions, TreatyMutationOptions, TreatyError, TreatyData };

package/dist/index.js

@@ -1,7 +1,9 @@
 // src/lib.ts
 import {
   mutationOptions,
-  queryOptions
+  queryOptions,
+  useMutation,
+  useQuery
 } from "@tanstack/react-query";
 function treatyMutationOptions(fn, options) {
   return mutationOptions({
@@ -27,10 +29,30 @@ function treatyQueryOptions(fn, options) {
     }
   });
 }
+function createTreatyMutationHook(fn, useOptions) {
+  return (options) => {
+    const initOptions = typeof useOptions === "function" ? useOptions() : useOptions;
+    return useMutation({
+      ...treatyMutationOptions(fn, initOptions),
+      ...options
+    });
+  };
+}
+function createTreatyQueryHook(fn, useOptions) {
+  return (options) => {
+    const initOptions = typeof useOptions === "function" ? useOptions() : useOptions;
+    return useQuery({
+      ...treatyQueryOptions(fn, initOptions),
+      ...options
+    });
+  };
+}
 export {
   treatyQueryOptions,
-  treatyMutationOptions
+  treatyMutationOptions,
+  createTreatyQueryHook,
+  createTreatyMutationHook
 };
 
-//# debugId=668F4CB9D073178564756E2164756E21
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsic3JjXFxsaWIudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbCiAgICAiaW1wb3J0IHR5cGUgeyBUcmVhdHkgfSBmcm9tIFwiQGVseXNpYWpzL2VkZW5cIjtcclxuaW1wb3J0IHtcclxuICBtdXRhdGlvbk9wdGlvbnMsXHJcbiAgcXVlcnlPcHRpb25zLFxyXG4gIHR5cGUgVXNlTXV0YXRpb25PcHRpb25zLFxyXG4gIHR5cGUgVXNlUXVlcnlPcHRpb25zLFxyXG59IGZyb20gXCJAdGFuc3RhY2svcmVhY3QtcXVlcnlcIjtcclxuXHJcbnR5cGUgVHJlYXR5UmVzcG9uc2UgPSBSZWNvcmQ8bnVtYmVyLCB1bmtub3duPjtcclxuXHJcbmV4cG9ydCB0eXBlIFRyZWF0eUZ1bmN0aW9uV2l0aG91dFBhcmFtczxcclxuICBUUmVzcG9uc2UgZXh0ZW5kcyBUcmVhdHlSZXNwb25zZSA9IFRyZWF0eVJlc3BvbnNlLFxyXG4+ID0gKCkgPT4gUHJvbWlzZTxUcmVhdHkuVHJlYXR5UmVzcG9uc2U8VFJlc3BvbnNlPj47XHJcblxyXG5leHBvcnQgdHlwZSBUcmVhdHlGdW5jdGlvbldpdGhQYXJhbXM8XHJcbiAgVFBhcmFtcyxcclxuICBUUmVzcG9uc2UgZXh0ZW5kcyBUcmVhdHlSZXNwb25zZSxcclxuPiA9IChwYXJhbXM6IFRQYXJhbXMpID0+IFByb21pc2U8VHJlYXR5LlRyZWF0eVJlc3BvbnNlPFRSZXNwb25zZT4+O1xyXG5cclxuZXhwb3J0IHR5cGUgVHJlYXR5RGF0YTxUUmVzcG9uc2UgZXh0ZW5kcyBUcmVhdHlSZXNwb25zZT4gPVxyXG4gIFRyZWF0eS5UcmVhdHlSZXNwb25zZTxUUmVzcG9uc2U+W1wiZGF0YVwiXTtcclxuXHJcbmV4cG9ydCB0eXBlIFRyZWF0eUVycm9yPFRSZXNwb25zZSBleHRlbmRzIFRyZWF0eVJlc3BvbnNlPiA9XHJcbiAgVHJlYXR5LlRyZWF0eVJlc3BvbnNlPFRSZXNwb25zZT5bXCJlcnJvclwiXTtcclxuXHJcbmV4cG9ydCB0eXBlIFRyZWF0eU11dGF0aW9uT3B0aW9uczxcclxuICBUVmFyaWFibGVzLFxyXG4gIFRSZXNwb25zZSBleHRlbmRzIFRyZWF0eVJlc3BvbnNlLFxyXG4+ID0gVXNlTXV0YXRpb25PcHRpb25zPFxyXG4gIFRyZWF0eURhdGE8VFJlc3BvbnNlPixcclxuICBUcmVhdHlFcnJvcjxUUmVzcG9uc2U+LFxyXG4gIFRWYXJpYWJsZXNcclxuPjtcclxuXHJcbmV4cG9ydCB0eXBlIFRyZWF0eVF1ZXJ5T3B0aW9uczxUUmVzcG9uc2UgZXh0ZW5kcyBSZWNvcmQ8bnVtYmVyLCB1bmtub3duPj4gPVxyXG4gIFVzZVF1ZXJ5T3B0aW9uczxUcmVhdHlEYXRhPFRSZXNwb25zZT4sIFRyZWF0eUVycm9yPFRSZXNwb25zZT4+O1xyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIHRyZWF0eU11dGF0aW9uT3B0aW9uczxUUmVzcG9uc2UgZXh0ZW5kcyBUcmVhdHlSZXNwb25zZT4oXHJcbiAgZm46IFRyZWF0eUZ1bmN0aW9uV2l0aG91dFBhcmFtczxUUmVzcG9uc2U+LFxyXG4gIG9wdGlvbnM/OiBPbWl0PFRyZWF0eU11dGF0aW9uT3B0aW9uczx2b2lkLCBUUmVzcG9uc2U+LCBcIm11dGF0aW9uRm5cIj4sXHJcbik6IFRyZWF0eU11dGF0aW9uT3B0aW9uczx2b2lkLCBUUmVzcG9uc2U+O1xyXG5leHBvcnQgZnVuY3Rpb24gdHJlYXR5TXV0YXRpb25PcHRpb25zPFxyXG4gIFRWYXJpYWJsZXMsXHJcbiAgVFJlc3BvbnNlIGV4dGVuZHMgVHJlYXR5UmVzcG9uc2UsXHJcbj4oXHJcbiAgZm46IFRyZWF0eUZ1bmN0aW9uV2l0aFBhcmFtczxUVmFyaWFibGVzLCBUUmVzcG9uc2U+LFxyXG4gIG9wdGlvbnM/OiBPbWl0PFRyZWF0eU11dGF0aW9uT3B0aW9uczxUVmFyaWFibGVzLCBUUmVzcG9uc2U+LCBcIm11dGF0aW9uRm5cIj4sXHJcbik6IFRyZWF0eU11dGF0aW9uT3B0aW9uczxUVmFyaWFibGVzLCBUUmVzcG9uc2U+O1xyXG5leHBvcnQgZnVuY3Rpb24gdHJlYXR5TXV0YXRpb25PcHRpb25zPFxyXG4gIFRWYXJpYWJsZXMsXHJcbiAgVFJlc3BvbnNlIGV4dGVuZHMgVHJlYXR5UmVzcG9uc2UsXHJcbj4oXHJcbiAgZm46XHJcbiAgICB8IFRyZWF0eUZ1bmN0aW9uV2l0aG91dFBhcmFtczxUUmVzcG9uc2U+XHJcbiAgICB8IFRyZWF0eUZ1bmN0aW9uV2l0aFBhcmFtczxUVmFyaWFibGVzLCBUUmVzcG9uc2U+LFxyXG4gIG9wdGlvbnM/OiBPbWl0PFRyZWF0eU11dGF0aW9uT3B0aW9uczxUVmFyaWFibGVzLCBUUmVzcG9uc2U+LCBcIm11dGF0aW9uRm5cIj4sXHJcbik6IFRyZWF0eU11dGF0aW9uT3B0aW9uczxUVmFyaWFibGVzLCBUUmVzcG9uc2U+IHtcclxuICB0eXBlIFREYXRhID0gVHJlYXR5RGF0YTxUUmVzcG9uc2U+O1xyXG4gIHR5cGUgVEVycm9yID0gVHJlYXR5RXJyb3I8VFJlc3BvbnNlPjtcclxuICByZXR1cm4gbXV0YXRpb25PcHRpb25zPFREYXRhLCBURXJyb3IsIFRWYXJpYWJsZXM+KHtcclxuICAgIC4uLm9wdGlvbnMsXHJcbiAgICBtdXRhdGlvbkZuOiBhc3luYyAodmFyaWFibGVzKSA9PiB7XHJcbiAgICAgIGNvbnN0IHJlc3BvbnNlID0gYXdhaXQgKFxyXG4gICAgICAgIGZuLmxlbmd0aCA9PT0gMCA/IChmbiBhcyAoKSA9PiBQcm9taXNlPFRyZWF0eS5UcmVhdHlSZXNwb25zZTxUUmVzcG9uc2U+PikoKSA6IChmbiBhcyBUcmVhdHlGdW5jdGlvbldpdGhQYXJhbXM8VFZhcmlhYmxlcywgVFJlc3BvbnNlPikodmFyaWFibGVzKVxyXG4gICAgICApO1xyXG4gICAgICBjb25zdCB7IGRhdGEsIGVycm9yIH0gPSByZXNwb25zZTtcclxuICAgICAgaWYgKGVycm9yKSB0aHJvdyBlcnJvcjtcclxuICAgICAgcmV0dXJuIGRhdGE7XHJcbiAgICB9LFxyXG4gIH0pO1xyXG59XHJcblxyXG5leHBvcnQgZnVuY3Rpb24gdHJlYXR5UXVlcnlPcHRpb25zPFxyXG4gIFRSZXNwb25zZSBleHRlbmRzIFRyZWF0eVJlc3BvbnNlID0gVHJlYXR5UmVzcG9uc2UsXHJcbj4oXHJcbiAgZm46IFRyZWF0eUZ1bmN0aW9uV2l0aG91dFBhcmFtczxUUmVzcG9uc2U+LFxyXG4gIG9wdGlvbnM6IE9taXQ8VHJlYXR5UXVlcnlPcHRpb25zPFRSZXNwb25zZT4sIFwicXVlcnlGblwiPixcclxuKTogVHJlYXR5UXVlcnlPcHRpb25zPFRSZXNwb25zZT4ge1xyXG4gIHR5cGUgVERhdGEgPSBUcmVhdHlEYXRhPFRSZXNwb25zZT47XHJcbiAgdHlwZSBURXJyb3IgPSBUcmVhdHlFcnJvcjxUUmVzcG9uc2U+O1xyXG4gIHJldHVybiBxdWVyeU9wdGlvbnM8VERhdGEsIFRFcnJvcj4oe1xyXG4gICAgLi4ub3B0aW9ucyxcclxuICAgIHF1ZXJ5Rm46IGFzeW5jICgpID0+IHtcclxuICAgICAgY29uc3QgcmVzcG9uc2UgPSBhd2FpdCBmbigpO1xyXG4gICAgICBjb25zdCB7IGRhdGEsIGVycm9yIH0gPSByZXNwb25zZTtcclxuICAgICAgaWYgKGVycm9yKSB0aHJvdyBlcnJvcjtcclxuICAgICAgcmV0dXJuIGRhdGE7XHJcbiAgICB9LFxyXG4gIH0pO1xyXG59IgogIF0sCiAgIm1hcHBpbmdzIjogIjtBQUNBO0FBQUE7QUFBQTtBQUFBO0FBK0NPLFNBQVMscUJBR2YsQ0FDQyxJQUdBLFNBQzhDO0FBQUEsRUFHOUMsT0FBTyxnQkFBMkM7QUFBQSxPQUM3QztBQUFBLElBQ0gsWUFBWSxPQUFPLGNBQWM7QUFBQSxNQUMvQixNQUFNLFdBQVcsT0FDZixHQUFHLFdBQVcsSUFBSyxHQUF1RCxJQUFLLEdBQXVELFNBQVM7QUFBQSxNQUVqSixRQUFRLE1BQU0sVUFBVTtBQUFBLE1BQ3hCLElBQUk7QUFBQSxRQUFPLE1BQU07QUFBQSxNQUNqQixPQUFPO0FBQUE7QUFBQSxFQUVYLENBQUM7QUFBQTtBQUdJLFNBQVMsa0JBRWYsQ0FDQyxJQUNBLFNBQytCO0FBQUEsRUFHL0IsT0FBTyxhQUE0QjtBQUFBLE9BQzlCO0FBQUEsSUFDSCxTQUFTLFlBQVk7QUFBQSxNQUNuQixNQUFNLFdBQVcsTUFBTSxHQUFHO0FBQUEsTUFDMUIsUUFBUSxNQUFNLFVBQVU7QUFBQSxNQUN4QixJQUFJO0FBQUEsUUFBTyxNQUFNO0FBQUEsTUFDakIsT0FBTztBQUFBO0FBQUEsRUFFWCxDQUFDO0FBQUE7IiwKICAiZGVidWdJZCI6ICI2NjhGNENCOUQwNzMxNzg1NjQ3NTZFMjE2NDc1NkUyMSIsCiAgIm5hbWVzIjogW10KfQ==
+//# debugId=7C7D36173641BA3264756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src\\lib.ts"],
  "sourcesContent": [
    "import type { Treaty } from \"@elysiajs/eden\";\r\nimport {\r\n  mutationOptions,\r\n  queryOptions,\r\n  useMutation,\r\n  useQuery,\r\n  type UseMutationOptions,\r\n  type UseMutationResult,\r\n  type UseQueryOptions,\r\n  type UseQueryResult,\r\n} from \"@tanstack/react-query\";\r\n\r\ntype TreatyResponse = Record<number, unknown>;\r\n\r\nexport type TreatyFunctionWithoutParams<\r\n  TResponse extends TreatyResponse = TreatyResponse,\r\n> = () => Promise<Treaty.TreatyResponse<TResponse>>;\r\n\r\nexport type TreatyFunctionWithParams<\r\n  TParams,\r\n  TResponse extends TreatyResponse,\r\n> = (params: TParams) => Promise<Treaty.TreatyResponse<TResponse>>;\r\n\r\nexport type TreatyFunction<\r\n  TParams,\r\n  TResponse extends TreatyResponse,\r\n> = TreatyFunctionWithoutParams<TResponse> | TreatyFunctionWithParams<TParams, TResponse>;\r\n\r\nexport type TreatyData<TResponse extends TreatyResponse> =\r\n  Treaty.TreatyResponse<TResponse>[\"data\"];\r\n\r\nexport type TreatyError<TResponse extends TreatyResponse> =\r\n  Treaty.TreatyResponse<TResponse>[\"error\"];\r\n\r\nexport type TreatyMutationOptions<\r\n  TVariables,\r\n  TResponse extends TreatyResponse,\r\n> = UseMutationOptions<\r\n  TreatyData<TResponse>,\r\n  TreatyError<TResponse>,\r\n  TVariables\r\n>;\r\n\r\nexport type UseTreatyMutationResult<\r\n  TVariables,\r\n  TResponse extends TreatyResponse,\r\n> = (\r\n  UseMutationResult<\r\n    TreatyData<TResponse>,\r\n    TreatyError<TResponse>,\r\n    TVariables\r\n  >\r\n);\r\n\r\nexport type UseTreatyQueryResult<\r\n  TResponse extends TreatyResponse,\r\n> = (\r\n  UseQueryResult<\r\n    TreatyData<TResponse>,\r\n    TreatyError<TResponse>\r\n  >\r\n);\r\n\r\nexport type TreatyQueryOptions<TResponse extends Record<number, unknown>> =\r\n  UseQueryOptions<TreatyData<TResponse>, TreatyError<TResponse>>;\r\n\r\nexport type UseTreatyMutationHook<\r\n  TVariables,\r\n  TResponse extends TreatyResponse,\r\n> = (\r\n  (options: Partial<Omit<TreatyMutationOptions<TVariables, TResponse>, \"mutationFn\">>) => \r\n    UseTreatyMutationResult<TVariables, TResponse>\r\n);\r\n\r\nexport type UseTreatyQueryHook<\r\n  TResponse extends TreatyResponse,\r\n> = (\r\n  (options: Partial<Omit<TreatyQueryOptions<TResponse>, \"queryFn\">>) => \r\n    UseTreatyQueryResult<TResponse>\r\n);\r\n\r\nexport function treatyMutationOptions<TResponse extends TreatyResponse>(\r\n  fn: TreatyFunctionWithoutParams<TResponse>,\r\n  options?: Omit<TreatyMutationOptions<void, TResponse>, \"mutationFn\">,\r\n): TreatyMutationOptions<void, TResponse>;\r\nexport function treatyMutationOptions<\r\n  TVariables,\r\n  TResponse extends TreatyResponse,\r\n>(\r\n  fn: TreatyFunctionWithParams<TVariables, TResponse>,\r\n  options?: Omit<TreatyMutationOptions<TVariables, TResponse>, \"mutationFn\">,\r\n): TreatyMutationOptions<TVariables, TResponse>;\r\nexport function treatyMutationOptions<\r\n  TVariables,\r\n  TResponse extends TreatyResponse,\r\n>(\r\n  fn: TreatyFunction<TVariables, TResponse>,\r\n  options?: Omit<TreatyMutationOptions<TVariables, TResponse>, \"mutationFn\">,\r\n): TreatyMutationOptions<TVariables, TResponse> {\r\n  type TData = TreatyData<TResponse>;\r\n  type TError = TreatyError<TResponse>;\r\n  return mutationOptions<TData, TError, TVariables>({\r\n    ...options,\r\n    mutationFn: async (variables) => {\r\n      const response = await (\r\n        fn.length === 0 ? (fn as () => Promise<Treaty.TreatyResponse<TResponse>>)() : (fn as TreatyFunctionWithParams<TVariables, TResponse>)(variables)\r\n      );\r\n      const { data, error } = response;\r\n      if (error) throw error;\r\n      return data;\r\n    },\r\n  });\r\n}\r\n\r\nexport function treatyQueryOptions<\r\n  TResponse extends TreatyResponse = TreatyResponse,\r\n>(\r\n  fn: TreatyFunctionWithoutParams<TResponse>,\r\n  options: Omit<TreatyQueryOptions<TResponse>, \"queryFn\">,\r\n): TreatyQueryOptions<TResponse> {\r\n  type TData = TreatyData<TResponse>;\r\n  type TError = TreatyError<TResponse>;\r\n  return queryOptions<TData, TError>({\r\n    ...options,\r\n    queryFn: async () => {\r\n      const response = await fn();\r\n      const { data, error } = response;\r\n      if (error) throw error;\r\n      return data;\r\n    },\r\n  });\r\n}\r\n\r\nexport function createTreatyMutationHook<TResponse extends TreatyResponse>(\r\n  fn: TreatyFunctionWithoutParams<TResponse>,\r\n  useOptions?: (\r\n    Omit<TreatyMutationOptions<void, TResponse>, \"mutationFn\"> | \r\n    (() => Omit<TreatyMutationOptions<void, TResponse>, \"mutationFn\">)\r\n  ),\r\n): UseTreatyMutationHook<void, TResponse>;\r\nexport function createTreatyMutationHook<\r\n  TVariables,\r\n  TResponse extends TreatyResponse,\r\n>(\r\n  fn: TreatyFunctionWithParams<TVariables, TResponse>,\r\n  useOptions?: (\r\n    Omit<TreatyMutationOptions<TVariables, TResponse>, \"mutationFn\"> | \r\n    (() => Omit<TreatyMutationOptions<TVariables, TResponse>, \"mutationFn\">)\r\n  ),\r\n): UseTreatyMutationHook<TVariables, TResponse>;\r\nexport function createTreatyMutationHook<\r\n  TVariables,\r\n  TResponse extends TreatyResponse,\r\n>(\r\n  fn: TreatyFunction<TVariables, TResponse>,\r\n  useOptions?: (\r\n    Omit<TreatyMutationOptions<TVariables, TResponse>, \"mutationFn\"> | \r\n    (() => Omit<TreatyMutationOptions<TVariables, TResponse>, \"mutationFn\">)\r\n  ),\r\n): UseTreatyMutationHook<TVariables, TResponse> {\r\n  return (options) => {\r\n    const initOptions = typeof useOptions === \"function\" ? useOptions() : useOptions;\r\n    return useMutation({\r\n      ...treatyMutationOptions(fn, initOptions),\r\n      ...options,\r\n    });\r\n  };\r\n}\r\n\r\nexport function createTreatyQueryHook<\r\n  TResponse extends TreatyResponse,\r\n>(\r\n  fn: TreatyFunctionWithoutParams<TResponse>,\r\n  useOptions: (\r\n    Omit<TreatyQueryOptions<TResponse>, \"queryFn\"> | \r\n    (() => Omit<TreatyQueryOptions<TResponse>, \"queryFn\">)\r\n  ),\r\n): UseTreatyQueryHook<TResponse> {\r\n  return (options) => {\r\n    const initOptions = typeof useOptions === \"function\" ? useOptions() : useOptions;\r\n    return useQuery({\r\n      ...treatyQueryOptions(fn, initOptions),\r\n      ...options,\r\n    });\r\n  };\r\n}"
  ],
  "mappings": ";AACA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2FO,SAAS,qBAGf,CACC,IACA,SAC8C;AAAA,EAG9C,OAAO,gBAA2C;AAAA,OAC7C;AAAA,IACH,YAAY,OAAO,cAAc;AAAA,MAC/B,MAAM,WAAW,OACf,GAAG,WAAW,IAAK,GAAuD,IAAK,GAAuD,SAAS;AAAA,MAEjJ,QAAQ,MAAM,UAAU;AAAA,MACxB,IAAI;AAAA,QAAO,MAAM;AAAA,MACjB,OAAO;AAAA;AAAA,EAEX,CAAC;AAAA;AAGI,SAAS,kBAEf,CACC,IACA,SAC+B;AAAA,EAG/B,OAAO,aAA4B;AAAA,OAC9B;AAAA,IACH,SAAS,YAAY;AAAA,MACnB,MAAM,WAAW,MAAM,GAAG;AAAA,MAC1B,QAAQ,MAAM,UAAU;AAAA,MACxB,IAAI;AAAA,QAAO,MAAM;AAAA,MACjB,OAAO;AAAA;AAAA,EAEX,CAAC;AAAA;AAoBI,SAAS,wBAGf,CACC,IACA,YAI8C;AAAA,EAC9C,OAAO,CAAC,YAAY;AAAA,IAClB,MAAM,cAAc,OAAO,eAAe,aAAa,WAAW,IAAI;AAAA,IACtE,OAAO,YAAY;AAAA,SACd,sBAAsB,IAAI,WAAW;AAAA,SACrC;AAAA,IACL,CAAC;AAAA;AAAA;AAIE,SAAS,qBAEf,CACC,IACA,YAI+B;AAAA,EAC/B,OAAO,CAAC,YAAY;AAAA,IAClB,MAAM,cAAc,OAAO,eAAe,aAAa,WAAW,IAAI;AAAA,IACtE,OAAO,SAAS;AAAA,SACX,mBAAmB,IAAI,WAAW;AAAA,SAClC;AAAA,IACL,CAAC;AAAA;AAAA;",
  "debugId": "7C7D36173641BA3264756E2164756E21",
  "names": []
}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eden2query",
   "description": "Type-safe Eden Treaty to React Query helpers",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "type": "module",
   "files": [
     "dist"