eden2query 0.3.3 → 0.3.5

package/README.md

@@ -67,14 +67,14 @@ const queryClient = new QueryClient();
 queryClient.prefetchQuery(getOptions);
 ```
 
-### Hook builders: `createQueryHook` / `createMutationHook`
+### Hook builders: `createTreatyQueryHook` / `createTreatyMutationHook`
 
-Create reusable, pre-configured hooks for a Treaty endpoint. Useful when you call the same endpoint in many components.
+Create reusable, pre-configured hooks for a Treaty endpoint. The second parameter is **`useOptions`**: either a static options object or a **function** that receives the hook’s call-time options and returns options (so you can use React hooks like `useQueryClient()` and forward or merge callbacks).
 
-**Query hook** — pass the Treaty GET thunk and required query options (e.g. `queryKey`):
+**Query hook** — pass the Treaty GET thunk and `useOptions` (object or function):
 
 ```ts
-const useResource = createQueryHook(
+const useResource = createTreatyQueryHook(
   () => client.api.resource.get({ query: { q: "hello" } }),
   { queryKey: ["resource"] },
 );
@@ -83,20 +83,40 @@ const useResource = createQueryHook(
 const { data } = useResource(); // or useResource({ refetchInterval: 1000 })
 ```
 
-**Mutation hook** — pass the Treaty mutation and optional base options:
+**Mutation hook** — pass the Treaty mutation and optional `useOptions`. Use a function when you need React hooks (e.g. for invalidation) or need to forward call-site callbacks:
 
 ```ts
-const usePostResource = createMutationHook(
+// Static useOptions
+const usePostResource = createTreatyMutationHook(
   (vars: { body: { name: string } }) => client.api.resource.post(vars.body),
   { onSuccess: () => console.log("Success") },
 );
 
+// useOptions as function — receives hook options, can use React hooks and forward callbacks
+const usePostResourceWithInvalidation = createTreatyMutationHook(
+  (vars: { body: { name: string } }) => client.api.resource.post(vars.body),
+  (options) => {
+    const queryClient = useQueryClient();
+    return {
+      onSettled(...args) {
+        queryClient.invalidateQueries({ queryKey: ["resource"] });
+        options.onSettled?.(...args);
+      },
+    };
+  },
+);
+
 // 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 ones passed to `createQueryHook` / `createMutationHook`.
+Hooks accept the same options as `useQuery` / `useMutation`; call-time options are merged with the base options from `useOptions`. When `useOptions` is a function, it receives those call-time options so you can forward callbacks (e.g. `options.onSettled?.(...args)`).
 
 ## API
 
@@ -109,9 +129,9 @@ Hooks accept the same options as `useQuery` / `useMutation`; call-time options a
 
 The optional second argument accepts all `mutationOptions` fields except `mutationFn` (e.g. `onSuccess`, `onSettled`, `onMutate`).
 
-**`createQueryHook(fn, queryOptions)`** — returns a hook that wraps `useQuery` with the given Treaty GET thunk and base query options. The returned hook accepts the same options as `useQuery`; call-time options are merged with the base options. Use when you want a reusable hook for a specific endpoint.
+**`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 `(options) => ...` that receives the hook’s call-time options and returns options; the function runs when the hook runs, so you can use React hooks inside it. Call-time options are merged with the returned options.
 
-**`createMutationHook(fn, mutationOptions?)`** — returns a hook that wraps `useMutation` with the given Treaty mutation and optional base mutation options. Same fn shapes as `treatyMutationOptions` (no-arg or with variables). The returned hook accepts the same options as `useMutation`. Use when you want a reusable hook for a specific mutation.
+**`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 `(options) => ...` that receives the hook’s call-time options and returns options (so you can use `useQueryClient()` for invalidation and forward callbacks like `options.onSettled?.(...args)`). The returned hook accepts the same options as `useMutation`.
 
 **`InferTreatyQueryOptions<T>`** — full `UseQueryOptions` type for a given Treaty query.
 

package/dist/index.d.ts

@@ -15,24 +15,29 @@ type TreatyMutationOptions<
 type UseTreatyMutationResult<
 	TVariables,
 	TResponse extends TreatyResponse
-> = (UseMutationResult<TreatyData<TResponse>, TreatyError<TResponse>, TVariables>);
-type UseTreatyQueryResult<TResponse extends TreatyResponse> = (UseQueryResult<TreatyData<TResponse>, TreatyError<TResponse>>);
+> = 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 UseTreatyQueryOptions<TResponse extends TreatyResponse> = Omit<TreatyQueryOptions<TResponse>, "queryFn">;
+type UseTreatyMutationOptions<
+	TVariables,
+	TResponse extends TreatyResponse
+> = Omit<TreatyMutationOptions<TVariables, TResponse>, "mutationFn">;
 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>;
+> = (options: Partial<UseTreatyMutationOptions<TVariables, TResponse>>) => UseTreatyMutationResult<TVariables, TResponse>;
+type UseTreatyQueryHook<TResponse extends TreatyResponse> = (options: Partial<UseTreatyQueryOptions<TResponse>>) => UseTreatyQueryResult<TResponse>;
+declare function treatyMutationOptions<TResponse extends TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, options?: UseTreatyMutationOptions<void, TResponse>): 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>;
-declare function createMutationHook<TResponse extends TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, options?: Omit<TreatyMutationOptions<void, TResponse>, "mutationFn">): UseTreatyMutationHook<void, TResponse>;
-declare function createMutationHook<
+>(fn: TreatyFunctionWithParams<TVariables, TResponse>, options?: UseTreatyMutationOptions<TVariables, TResponse>): TreatyMutationOptions<TVariables, TResponse>;
+declare function treatyQueryOptions<TResponse extends TreatyResponse = TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, options: UseTreatyQueryOptions<TResponse>): TreatyQueryOptions<TResponse>;
+declare function createTreatyMutationHook<TResponse extends TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, useOptions?: UseTreatyMutationOptions<void, TResponse> | ((options: Partial<UseTreatyMutationOptions<void, TResponse>>) => UseTreatyMutationOptions<void, TResponse>)): UseTreatyMutationHook<void, TResponse>;
+declare function createTreatyMutationHook<
 	TVariables,
 	TResponse extends TreatyResponse
->(fn: TreatyFunctionWithParams<TVariables, TResponse>, options?: Omit<TreatyMutationOptions<TVariables, TResponse>, "mutationFn">): UseTreatyMutationHook<TVariables, TResponse>;
-declare function createQueryHook<TResponse extends TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, createOptions: Omit<TreatyQueryOptions<TResponse>, "queryFn">): UseTreatyQueryHook<TResponse>;
-export { treatyQueryOptions, treatyMutationOptions, createQueryHook, createMutationHook, UseTreatyQueryHook, UseTreatyMutationHook, TreatyQueryOptions, TreatyMutationOptions, TreatyError, TreatyData };
+>(fn: TreatyFunctionWithParams<TVariables, TResponse>, useOptions?: UseTreatyMutationOptions<TVariables, TResponse> | ((options: Partial<UseTreatyMutationOptions<TVariables, TResponse>>) => UseTreatyMutationOptions<TVariables, TResponse>)): UseTreatyMutationHook<TVariables, TResponse>;
+declare function createTreatyQueryHook<TResponse extends TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, useOptions: UseTreatyQueryOptions<TResponse> | ((options: Partial<UseTreatyQueryOptions<TResponse>>) => UseTreatyQueryOptions<TResponse>)): UseTreatyQueryHook<TResponse>;
+export { treatyQueryOptions, treatyMutationOptions, createTreatyQueryHook, createTreatyMutationHook, UseTreatyQueryOptions, UseTreatyQueryHook, UseTreatyMutationOptions, UseTreatyMutationHook, TreatyQueryOptions, TreatyMutationOptions, TreatyError, TreatyData };

package/dist/index.js

@@ -29,18 +29,20 @@ function treatyQueryOptions(fn, options) {
     }
   });
 }
-function createMutationHook(fn, createOptions) {
+function createTreatyMutationHook(fn, useOptions) {
   return (options) => {
+    const initOptions = typeof useOptions === "function" ? useOptions(options) : useOptions;
     return useMutation({
-      ...treatyMutationOptions(fn, createOptions),
+      ...treatyMutationOptions(fn, initOptions),
       ...options
     });
   };
 }
-function createQueryHook(fn, createOptions) {
+function createTreatyQueryHook(fn, useOptions) {
   return (options) => {
+    const initOptions = typeof useOptions === "function" ? useOptions(options) : useOptions;
     return useQuery({
-      ...treatyQueryOptions(fn, createOptions),
+      ...treatyQueryOptions(fn, initOptions),
       ...options
     });
   };
@@ -48,9 +50,9 @@ function createQueryHook(fn, createOptions) {
 export {
   treatyQueryOptions,
   treatyMutationOptions,
-  createQueryHook,
-  createMutationHook
+  createTreatyQueryHook,
+  createTreatyMutationHook
 };
 
-//# debugId=C7B700FB8AB692F864756E2164756E21
-//# 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 createMutationHook<TResponse extends TreatyResponse>(\r\n  fn: TreatyFunctionWithoutParams<TResponse>,\r\n  options?: Omit<TreatyMutationOptions<void, TResponse>, \"mutationFn\">,\r\n): UseTreatyMutationHook<void, TResponse>;\r\nexport function createMutationHook<\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): UseTreatyMutationHook<TVariables, TResponse>;\r\nexport function createMutationHook<\r\n  TVariables,\r\n  TResponse extends TreatyResponse,\r\n>(\r\n  fn: TreatyFunction<TVariables, TResponse>,\r\n  createOptions?: Omit<TreatyMutationOptions<TVariables, TResponse>, \"mutationFn\">,\r\n): UseTreatyMutationHook<TVariables, TResponse> {\r\n  return (options) => {\r\n    return useMutation({\r\n      ...treatyMutationOptions(fn, createOptions),\r\n      ...options,\r\n    });\r\n  };\r\n}\r\n\r\nexport function createQueryHook<\r\n  TResponse extends TreatyResponse,\r\n>(\r\n  fn: TreatyFunctionWithoutParams<TResponse>,\r\n  createOptions: Omit<TreatyQueryOptions<TResponse>, \"queryFn\">,\r\n): UseTreatyQueryHook<TResponse> {\r\n  return (options) => {\r\n    return useQuery({\r\n      ...treatyQueryOptions(fn, createOptions),\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;AAcI,SAAS,kBAGf,CACC,IACA,eAC8C;AAAA,EAC9C,OAAO,CAAC,YAAY;AAAA,IAClB,OAAO,YAAY;AAAA,SACd,sBAAsB,IAAI,aAAa;AAAA,SACvC;AAAA,IACL,CAAC;AAAA;AAAA;AAIE,SAAS,eAEf,CACC,IACA,eAC+B;AAAA,EAC/B,OAAO,CAAC,YAAY;AAAA,IAClB,OAAO,SAAS;AAAA,SACX,mBAAmB,IAAI,aAAa;AAAA,SACpC;AAAA,IACL,CAAC;AAAA;AAAA;",
  "debugId": "C7B700FB8AB692F864756E2164756E21",
  "names": []
}
+//# debugId=DB20669AEF2C954E64756E2164756E21
+//# 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<TParams, TResponse extends TreatyResponse> =\r\n  | TreatyFunctionWithoutParams<TResponse>\r\n  | 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> = UseMutationResult<\r\n  TreatyData<TResponse>,\r\n  TreatyError<TResponse>,\r\n  TVariables\r\n>;\r\n\r\nexport type UseTreatyQueryResult<TResponse extends TreatyResponse> =\r\n  UseQueryResult<TreatyData<TResponse>, TreatyError<TResponse>>;\r\n\r\nexport type TreatyQueryOptions<TResponse extends Record<number, unknown>> =\r\n  UseQueryOptions<TreatyData<TResponse>, TreatyError<TResponse>>;\r\n\r\nexport type UseTreatyQueryOptions<TResponse extends TreatyResponse> = Omit<\r\n  TreatyQueryOptions<TResponse>,\r\n  \"queryFn\"\r\n>;\r\n\r\nexport type UseTreatyMutationOptions<\r\n  TVariables,\r\n  TResponse extends TreatyResponse,\r\n> = Omit<TreatyMutationOptions<TVariables, TResponse>, \"mutationFn\">;\r\n\r\nexport type UseTreatyMutationHook<\r\n  TVariables,\r\n  TResponse extends TreatyResponse,\r\n> = (\r\n  options: Partial<UseTreatyMutationOptions<TVariables, TResponse>>,\r\n) => UseTreatyMutationResult<TVariables, TResponse>;\r\n\r\nexport type UseTreatyQueryHook<TResponse extends TreatyResponse> = (\r\n  options: Partial<UseTreatyQueryOptions<TResponse>>,\r\n) => UseTreatyQueryResult<TResponse>;\r\n\r\nexport function treatyMutationOptions<TResponse extends TreatyResponse>(\r\n  fn: TreatyFunctionWithoutParams<TResponse>,\r\n  options?: UseTreatyMutationOptions<void, TResponse>,\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?: UseTreatyMutationOptions<TVariables, TResponse>,\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?: UseTreatyMutationOptions<TVariables, TResponse>,\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 (fn.length === 0\r\n        ? (fn as () => Promise<Treaty.TreatyResponse<TResponse>>)()\r\n        : (fn as TreatyFunctionWithParams<TVariables, TResponse>)(variables));\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: UseTreatyQueryOptions<TResponse>,\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    | UseTreatyMutationOptions<void, TResponse>\r\n    | ((options: Partial<UseTreatyMutationOptions<void, TResponse>>) => UseTreatyMutationOptions<void, TResponse>),\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    | UseTreatyMutationOptions<TVariables, TResponse>\r\n    | ((options: Partial<UseTreatyMutationOptions<TVariables, TResponse>>) => UseTreatyMutationOptions<TVariables, TResponse>),\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    | UseTreatyMutationOptions<TVariables, TResponse>\r\n    | ((options: Partial<UseTreatyMutationOptions<TVariables, TResponse>>) => UseTreatyMutationOptions<TVariables, TResponse>),\r\n): UseTreatyMutationHook<TVariables, TResponse> {\r\n  return (options) => {\r\n    const initOptions =\r\n      typeof useOptions === \"function\" ? useOptions(options) : 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<TResponse extends TreatyResponse>(\r\n  fn: TreatyFunctionWithoutParams<TResponse>,\r\n  useOptions:\r\n    | UseTreatyQueryOptions<TResponse>\r\n    | ((options: Partial<UseTreatyQueryOptions<TResponse>>) => UseTreatyQueryOptions<TResponse>),\r\n): UseTreatyQueryHook<TResponse> {\r\n  return (options) => {\r\n    const initOptions =\r\n      typeof useOptions === \"function\" ? useOptions(options) : useOptions;\r\n    return useQuery({\r\n      ...treatyQueryOptions(fn, initOptions),\r\n      ...options,\r\n    });\r\n  };\r\n}\r\n"
  ],
  "mappings": ";AACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwFO,SAAS,qBAGf,CACC,IACA,SAC8C;AAAA,EAG9C,OAAO,gBAA2C;AAAA,OAC7C;AAAA,IACH,YAAY,OAAO,cAAc;AAAA,MAC/B,MAAM,WAAW,OAAO,GAAG,WAAW,IACjC,GAAuD,IACvD,GAAuD,SAAS;AAAA,MACrE,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;AAkBI,SAAS,wBAGf,CACC,IACA,YAG8C;AAAA,EAC9C,OAAO,CAAC,YAAY;AAAA,IAClB,MAAM,cACJ,OAAO,eAAe,aAAa,WAAW,OAAO,IAAI;AAAA,IAC3D,OAAO,YAAY;AAAA,SACd,sBAAsB,IAAI,WAAW;AAAA,SACrC;AAAA,IACL,CAAC;AAAA;AAAA;AAIE,SAAS,qBAAuD,CACrE,IACA,YAG+B;AAAA,EAC/B,OAAO,CAAC,YAAY;AAAA,IAClB,MAAM,cACJ,OAAO,eAAe,aAAa,WAAW,OAAO,IAAI;AAAA,IAC3D,OAAO,SAAS;AAAA,SACX,mBAAmB,IAAI,WAAW;AAAA,SAClC;AAAA,IACL,CAAC;AAAA;AAAA;",
  "debugId": "DB20669AEF2C954E64756E2164756E21",
  "names": []
}

package/package.json

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