eden2query 0.3.5 → 0.3.6

package/README.md

@@ -67,56 +67,58 @@ const queryClient = new QueryClient();
 queryClient.prefetchQuery(getOptions);
 ```
 
-### Hook builders: `createTreatyQueryHook` / `createTreatyMutationHook`
+### Hook builders: `treatyQueryHook` / `treatyMutationHook`
 
-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).
+Create reusable, pre-configured hooks for a Treaty endpoint. The first parameter is the **Treaty function**, and the second optional parameter is **`useOptions`** — a hook that returns default options (so you can use React hooks like `useQueryClient()`).
 
-**Query hook** — pass the Treaty GET thunk and `useOptions` (object or function):
+**Mutation hook** — pass the mutation function and optional `useOptions`:
 
 ```ts
-const useResource = createTreatyQueryHook(
-  () => client.api.resource.get({ query: { q: "hello" } }),
-  { queryKey: ["resource"] },
-);
+function myMutationFn(variables: { name: string; q: string }) {
+  return client.api.resource.post(
+    { name: variables.name },
+    { query: { q: variables.q } }
+  );
+}
+
+const useMutationHook = treatyMutationHook(myMutationFn, () => {
+  const queryClient = useQueryClient();
+  return {
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["resource"] });
+    },
+  };
+});
 
 // In a component
-const { data } = useResource(); // or useResource({ refetchInterval: 1000 })
+const mutationResult = useMutationHook({
+  onSuccess: (data, variables) => {
+    console.log(data, variables);
+  },
+});
+mutationResult.mutate({
+  name: "World",
+  q: "hello",
+});
 ```
 
-**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:
+**Query hook** — pass the query function and optional `useOptions` that receives the `request` and returns options including `queryKey`:
 
 ```ts
-// Static useOptions
-const usePostResource = createTreatyMutationHook(
-  (vars: { body: { name: string } }) => client.api.resource.post(vars.body),
-  { onSuccess: () => console.log("Success") },
-);
+function myQueryFn(request: { q: string }) {
+  return client.api.resource.get({ query: { q: request.q } });
+}
 
-// 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);
-      },
-    };
-  },
-);
+const useQueryHook = treatyQueryHook(myQueryFn, (request) => ({
+  queryKey: ["resource", request] as const,
+  enabled: true,
+}));
 
 // In a component
-const postMutation = usePostResource();
-postMutation.mutate({ body: { name: "World" } });
-
-const postWithInvalidation = usePostResourceWithInvalidation({
-  onSuccess: () => console.log("Success"),
-});
-postWithInvalidation.mutate({ body: { name: "World" } });
+const queryResult = useQueryHook({ q: "hello" });
 ```
 
-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)`).
+Hooks accept the same options as `useQuery` / `useMutation`; call-time options are merged with the base options from `useOptions`. Callbacks are chained: base options run first, then `useOptions` callbacks, then call-site callbacks.
 
 ## API
 
@@ -125,13 +127,13 @@ Hooks accept the same options as `useQuery` / `useMutation`; call-time options a
 **`treatyMutationOptions(fn, mutationOptions?)`** — wraps a Treaty mutation into `mutationOptions`. Two shapes:
 
 - **No-arg:** `fn` is `() => Promise<...>`. Use when the mutation has no call-time input (e.g. DELETE with fixed path params). `mutate()` is called with no arguments.
-- **With variables:** `fn` is `(vars) => Promise<...>`. Use for POST/PUT etc. `mutate(vars)` receives a single object (e.g. `{ body, query }` or the Treaty method’s first argument). You can pass the Treaty method directly when its signature matches (e.g. `client.api.resource({ id }).put`).
+- **With variables:** `fn` is `(vars) => Promise<...>`. Use for POST/PUT etc. `mutate(vars)` receives a single object (e.g. `{ body, query }` or the Treaty method's first argument). You can pass the Treaty method directly when its signature matches (e.g. `client.api.resource({ id }).put`).
 
 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 `(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.
+**`treatyMutationHook(mutationFn, useOptions?)`** — returns a hook that wraps `useMutation` with the given Treaty mutation function. **`mutationFn`** is the Treaty mutation function (e.g. `myMutationFn`). **`useOptions`** is optional; it's a hook that returns default mutation options (so you can use `useQueryClient()` for invalidation). The returned hook accepts the same options as `useMutation`; callbacks are chained (base → `useOptions` → call-site).
 
-**`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`.
+**`treatyQueryHook(queryFn, useOptions?)`** — returns a hook that wraps `useQuery` with the given Treaty query function. **`queryFn`** is the Treaty query function (e.g. `myQueryFn`). **`useOptions`** is optional; it's a function `(request) => ...` that receives the query request and returns default query options including `queryKey` (so you can use React hooks like `useQueryClient()`). The returned hook is called with `(request, options?)`; callbacks are chained (base → `useOptions` → call-site).
 
 **`InferTreatyQueryOptions<T>`** — full `UseQueryOptions` type for a given Treaty query.
 

package/dist/index.d.ts

@@ -1,43 +1,48 @@
 import { Treaty } from "@elysiajs/eden";
-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<
-	TParams,
-	TResponse extends TreatyResponse
-> = (params: TParams) => Promise<Treaty.TreatyResponse<TResponse>>;
-type TreatyData<TResponse extends TreatyResponse> = Treaty.TreatyResponse<TResponse>["data"];
-type TreatyError<TResponse extends TreatyResponse> = Treaty.TreatyResponse<TResponse>["error"];
-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 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<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?: 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>, 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 };
+import { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
+type TreatyFunction = (...request: any[]) => Promise<Treaty.TreatyResponse<Record<number, unknown>>>;
+type InferTreatyData<TFn extends TreatyFunction> = Awaited<ReturnType<TFn>>["data"];
+type InferTreatyError<TFn extends TreatyFunction> = Awaited<ReturnType<TFn>>["error"];
+type InferTreatyRequest<TFn extends TreatyFunction> = Parameters<TFn>[0];
+type InferTreatyMutationOptions<TFn extends TreatyFunction> = UseMutationOptions<InferTreatyData<TFn>, InferTreatyError<TFn>, InferTreatyRequest<TFn>>;
+type InferTreatyQueryOptions<
+	TFn extends TreatyFunction,
+	TQueryKey extends QueryKey = unknown[]
+> = UseQueryOptions<InferTreatyData<TFn>, InferTreatyError<TFn>, InferTreatyData<TFn>, TQueryKey>;
+declare function treatyMutationOptions<TFn extends TreatyFunction>(options: {
+	mutationFn: TFn;
+} & Omit<InferTreatyMutationOptions<TFn>, "mutationFn">): InferTreatyMutationOptions<TFn>;
+declare function treatyQueryOptions<
+	TFn extends TreatyFunction,
+	const TQueryKey extends QueryKey
+>(options: {
+	queryKey: TQueryKey;
+	queryFn: TFn;
+} & Omit<InferTreatyQueryOptions<TFn, TQueryKey>, "queryKey" | "queryFn">): InferTreatyQueryOptions<TFn, TQueryKey>;
+type UseTreatyMutationResult<TFn extends TreatyFunction> = UseMutationResult<InferTreatyData<TFn>, InferTreatyError<TFn>, InferTreatyRequest<TFn>>;
+type UseTreatyQueryResult<
+	TFn extends TreatyFunction,
+	TQueryKey extends QueryKey = unknown[]
+> = UseQueryResult<InferTreatyData<TFn>, InferTreatyError<TFn>>;
+type TreatyMutationHookOptions<TFn extends TreatyFunction> = Omit<InferTreatyMutationOptions<TFn>, "mutationFn">;
+type TreatyQueryHookOptions<
+	TFn extends TreatyFunction,
+	TQueryKey extends QueryKey = unknown[]
+> = Omit<InferTreatyQueryOptions<TFn, TQueryKey>, "queryKey" | "queryFn">;
+type TreatyQueryHookUseOptions<
+	TFn extends TreatyFunction,
+	TQueryKey extends QueryKey = unknown[]
+> = {
+	queryKey: TQueryKey;
+} & TreatyQueryHookOptions<TFn, TQueryKey>;
+type TreatyMutationHook<TFn extends TreatyFunction> = (options?: TreatyMutationHookOptions<TFn>) => UseTreatyMutationResult<TFn>;
+type TreatyQueryHook<
+	TFn extends TreatyFunction,
+	TQueryKey extends QueryKey = unknown[]
+> = (request: InferTreatyRequest<TFn>, options?: TreatyQueryHookOptions<TFn, TQueryKey>) => UseTreatyQueryResult<TFn, TQueryKey>;
+declare function treatyMutationHook<TFn extends TreatyFunction>(mutationFn: TFn, useOptions?: () => TreatyMutationHookOptions<TFn>): TreatyMutationHook<TFn>;
+declare function treatyQueryHook<
+	TFn extends TreatyFunction,
+	TQueryKey extends QueryKey = QueryKey
+>(queryFn: TFn, useOptions?: (request: InferTreatyRequest<TFn>) => TreatyQueryHookUseOptions<TFn, TQueryKey>): TreatyQueryHook<TFn, TQueryKey>;
+export { treatyQueryOptions, treatyQueryHook, treatyMutationOptions, treatyMutationHook, InferTreatyQueryOptions, InferTreatyMutationOptions };

package/dist/index.js

@@ -1,15 +1,57 @@
-// src/lib.ts
-import {
-  mutationOptions,
-  queryOptions,
-  useMutation,
-  useQuery
-} from "@tanstack/react-query";
-function treatyMutationOptions(fn, options) {
+// src/treaty.ts
+import { mutationOptions, queryOptions, useMutation, useQuery } from "@tanstack/react-query";
+
+// src/utils.ts
+function mergeMutationOptions(base, options) {
+  if (!options)
+    return base;
+  const { onSuccess, onError, onSettled, onMutate, ...rest } = options;
+  return {
+    ...base,
+    ...rest,
+    ...onMutate !== undefined && {
+      onMutate: async (variables, context) => {
+        const prev = await base.onMutate?.(variables, context);
+        const next = await options.onMutate?.(variables, context);
+        return next !== undefined ? next : prev;
+      }
+    },
+    ...onSuccess !== undefined && {
+      onSuccess: async (data, variables, onMutateResult, context) => {
+        await base.onSuccess?.(data, variables, onMutateResult, context);
+        await options.onSuccess?.(data, variables, onMutateResult, context);
+      }
+    },
+    ...onError !== undefined && {
+      onError: async (error, variables, onMutateResult, context) => {
+        await base.onError?.(error, variables, onMutateResult, context);
+        await options.onError?.(error, variables, onMutateResult, context);
+      }
+    },
+    ...onSettled !== undefined && {
+      onSettled: async (data, error, variables, onMutateResult, context) => {
+        await base.onSettled?.(data, error, variables, onMutateResult, context);
+        await options.onSettled?.(data, error, variables, onMutateResult, context);
+      }
+    }
+  };
+}
+function mergeQueryOptions(base, options) {
+  if (!options)
+    return base;
+  return {
+    ...base,
+    ...options
+  };
+}
+
+// src/treaty.ts
+function treatyMutationOptions(options) {
+  const { mutationFn, ...rest } = options;
   return mutationOptions({
-    ...options,
+    ...rest,
     mutationFn: async (variables) => {
-      const response = await (fn.length === 0 ? fn() : fn(variables));
+      const response = await mutationFn(variables);
       const { data, error } = response;
       if (error)
         throw error;
@@ -17,11 +59,13 @@ function treatyMutationOptions(fn, options) {
     }
   });
 }
-function treatyQueryOptions(fn, options) {
+function treatyQueryOptions(options) {
+  const { queryFn, queryKey, ...rest } = options;
   return queryOptions({
-    ...options,
+    ...rest,
+    queryKey,
     queryFn: async () => {
-      const response = await fn();
+      const response = await queryFn();
       const { data, error } = response;
       if (error)
         throw error;
@@ -29,30 +73,32 @@ function treatyQueryOptions(fn, options) {
     }
   });
 }
-function createTreatyMutationHook(fn, useOptions) {
+function treatyMutationHook(mutationFn, useOptions) {
   return (options) => {
-    const initOptions = typeof useOptions === "function" ? useOptions(options) : useOptions;
-    return useMutation({
-      ...treatyMutationOptions(fn, initOptions),
-      ...options
-    });
+    const baseOptions = treatyMutationOptions({ mutationFn });
+    const defaultOptions = useOptions?.();
+    const merged = mergeMutationOptions(mergeMutationOptions(baseOptions, defaultOptions), options);
+    return useMutation(merged);
   };
 }
-function createTreatyQueryHook(fn, useOptions) {
-  return (options) => {
-    const initOptions = typeof useOptions === "function" ? useOptions(options) : useOptions;
-    return useQuery({
-      ...treatyQueryOptions(fn, initOptions),
-      ...options
+function treatyQueryHook(queryFn, useOptions) {
+  return (request, options) => {
+    const defaultOptions = useOptions?.(request);
+    const baseOptions = treatyQueryOptions({
+      queryKey: defaultOptions?.queryKey ?? ["resource", request],
+      queryFn: () => queryFn(request),
+      ...defaultOptions
     });
+    const merged = mergeQueryOptions(baseOptions, options);
+    return useQuery(merged);
   };
 }
 export {
   treatyQueryOptions,
+  treatyQueryHook,
   treatyMutationOptions,
-  createTreatyQueryHook,
-  createTreatyMutationHook
+  treatyMutationHook
 };
 
-//# 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": []
}
+//# debugId=3974E80E199B9F8064756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src\\treaty.ts", "src\\utils.ts"],
  "sourcesContent": [
    "import type { Treaty } from \"@elysiajs/eden\";\r\nimport { mutationOptions, queryOptions, useMutation, useQuery, type QueryKey, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult } from \"@tanstack/react-query\";\r\nimport { mergeMutationOptions, mergeQueryOptions } from \"./utils\";\r\n\r\ntype TreatyFunction = (...request: any[]) => \r\n  Promise<Treaty.TreatyResponse<Record<number, unknown>>>;\r\n\r\nexport type InferTreatyData<\r\n  TFn extends TreatyFunction,\r\n> = Awaited<ReturnType<TFn>>[\"data\"];\r\n\r\nexport type InferTreatyError<\r\n  TFn extends TreatyFunction,\r\n> = Awaited<ReturnType<TFn>>[\"error\"];\r\n\r\nexport type InferTreatyRequest<\r\n  TFn extends TreatyFunction,\r\n> = Parameters<TFn>[0];\r\n\r\nexport type InferTreatyMutationOptions<\r\n  TFn extends TreatyFunction,\r\n> = UseMutationOptions<\r\n  InferTreatyData<TFn>,\r\n  InferTreatyError<TFn>,\r\n  InferTreatyRequest<TFn>\r\n>;\r\n\r\nexport type InferTreatyQueryOptions<\r\n  TFn extends TreatyFunction,\r\n  TQueryKey extends QueryKey = unknown[],\r\n> = UseQueryOptions<\r\n  InferTreatyData<TFn>,\r\n  InferTreatyError<TFn>,\r\n  InferTreatyData<TFn>,\r\n  TQueryKey\r\n>;\r\n\r\nexport function treatyMutationOptions<TFn extends TreatyFunction>(\r\n  options: {\r\n    mutationFn: TFn;\r\n  } & Omit<\r\n    InferTreatyMutationOptions<TFn>,\r\n    \"mutationFn\"\r\n  >\r\n): InferTreatyMutationOptions<TFn> {\r\n  type TData = InferTreatyData<TFn>;\r\n  type TError = InferTreatyError<TFn>;\r\n  type TVariables = InferTreatyRequest<TFn>;\r\n  const { mutationFn, ...rest } = options;\r\n  return mutationOptions<TData, TError, TVariables>({\r\n    ...rest,\r\n    mutationFn: async (variables) => {\r\n      const response = await mutationFn(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  TFn extends TreatyFunction,\r\n  const TQueryKey extends QueryKey,\r\n>(\r\n  options: {\r\n    queryKey: TQueryKey;\r\n    queryFn: TFn;\r\n  } & Omit<\r\n    InferTreatyQueryOptions<TFn, TQueryKey>,\r\n    \"queryKey\" | \"queryFn\"\r\n  >\r\n): InferTreatyQueryOptions<TFn, TQueryKey> {\r\n  type TData = InferTreatyData<TFn>;\r\n  type TError = InferTreatyError<TFn>;\r\n  const { queryFn, queryKey, ...rest } = options;\r\n  return queryOptions<TData, TError, TData, TQueryKey>({\r\n    ...rest,\r\n    queryKey,\r\n    queryFn: async () => {\r\n      const response = await queryFn();\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 type UseTreatyMutationResult<TFn extends TreatyFunction> = UseMutationResult<\r\n  InferTreatyData<TFn>,\r\n  InferTreatyError<TFn>,\r\n  InferTreatyRequest<TFn>\r\n>;\r\n\r\nexport type UseTreatyQueryResult<\r\n  TFn extends TreatyFunction,\r\n  TQueryKey extends QueryKey = unknown[],\r\n> = UseQueryResult<\r\n  InferTreatyData<TFn>,\r\n  InferTreatyError<TFn>\r\n>;\r\n\r\nexport type TreatyMutationHookOptions<TFn extends TreatyFunction> = Omit<\r\n  InferTreatyMutationOptions<TFn>,\r\n  \"mutationFn\"\r\n>;\r\n\r\nexport type TreatyQueryHookOptions<\r\n  TFn extends TreatyFunction,\r\n  TQueryKey extends QueryKey = unknown[],\r\n> = Omit<\r\n  InferTreatyQueryOptions<TFn, TQueryKey>,\r\n  \"queryKey\" | \"queryFn\"\r\n>;\r\n\r\nexport type TreatyQueryHookUseOptions<\r\n  TFn extends TreatyFunction,\r\n  TQueryKey extends QueryKey = unknown[],\r\n> = {\r\n  queryKey: TQueryKey;\r\n} & TreatyQueryHookOptions<TFn, TQueryKey>;\r\n\r\nexport type TreatyMutationHook<TFn extends TreatyFunction> = (\r\n  options?: TreatyMutationHookOptions<TFn>\r\n) => UseTreatyMutationResult<TFn>;\r\n\r\nexport type TreatyQueryHook<\r\n  TFn extends TreatyFunction,\r\n  TQueryKey extends QueryKey = unknown[],\r\n> = (\r\n  request: InferTreatyRequest<TFn>,\r\n  options?: TreatyQueryHookOptions<TFn, TQueryKey>\r\n) => UseTreatyQueryResult<TFn, TQueryKey>;\r\n\r\nexport function treatyMutationHook<TFn extends TreatyFunction>(\r\n  mutationFn: TFn,\r\n  useOptions?: () => TreatyMutationHookOptions<TFn>\r\n): TreatyMutationHook<TFn> {\r\n  return (options) => {\r\n    const baseOptions = treatyMutationOptions({ mutationFn });\r\n    const defaultOptions = useOptions?.();\r\n    const merged = mergeMutationOptions(\r\n      mergeMutationOptions(baseOptions, defaultOptions),\r\n      options\r\n    );\r\n    return useMutation(merged);\r\n  };\r\n}\r\n\r\nexport function treatyQueryHook<\r\n  TFn extends TreatyFunction,\r\n  TQueryKey extends QueryKey = QueryKey,\r\n>(\r\n  queryFn: TFn,\r\n  useOptions?: (\r\n    request: InferTreatyRequest<TFn>\r\n  ) => TreatyQueryHookUseOptions<TFn, TQueryKey>\r\n): TreatyQueryHook<TFn, TQueryKey> {\r\n  return (request, options) => {\r\n    const defaultOptions = useOptions?.(request);\r\n    const baseOptions = treatyQueryOptions({\r\n      queryKey: (defaultOptions?.queryKey ?? ([\"resource\", request] as unknown)) as TQueryKey,\r\n      queryFn: (() => queryFn(request)) as TFn,\r\n      ...defaultOptions,\r\n    });\r\n    const merged = mergeQueryOptions(\r\n      baseOptions,\r\n      options as UseQueryOptions<\r\n        InferTreatyData<TFn>,\r\n        InferTreatyError<TFn>,\r\n        InferTreatyData<TFn>,\r\n        TQueryKey\r\n      > | undefined\r\n    );\r\n    return useQuery(merged);\r\n  };\r\n}",
    "import type { QueryKey, UseMutationOptions, UseQueryOptions } from \"@tanstack/react-query\";\r\n\r\nexport function mergeMutationOptions<TData, TError, TVariables, TContext>(\r\n  base: UseMutationOptions<TData, TError, TVariables, TContext>,\r\n  options?: Partial<UseMutationOptions<TData, TError, TVariables, TContext>>\r\n): UseMutationOptions<TData, TError, TVariables, TContext> {\r\n  if (!options) return base;\r\n  const { onSuccess, onError, onSettled, onMutate, ...rest } = options;\r\n  return {\r\n    ...base,\r\n    ...rest,\r\n    ...(onMutate !== undefined && {\r\n      onMutate: async (variables, context) => {\r\n        const prev = await base.onMutate?.(variables, context);\r\n        const next = await options.onMutate?.(variables, context);\r\n        return (next !== undefined ? next : prev) as TContext;\r\n      },\r\n    }),\r\n    ...(onSuccess !== undefined && {\r\n      onSuccess: async (data, variables, onMutateResult, context) => {\r\n        await base.onSuccess?.(data, variables, onMutateResult, context);\r\n        await options.onSuccess?.(data, variables, onMutateResult, context);\r\n      },\r\n    }),\r\n    ...(onError !== undefined && {\r\n      onError: async (error, variables, onMutateResult, context) => {\r\n        await base.onError?.(error, variables, onMutateResult, context);\r\n        await options.onError?.(error, variables, onMutateResult, context);\r\n      },\r\n    }),\r\n    ...(onSettled !== undefined && {\r\n      onSettled: async (data, error, variables, onMutateResult, context) => {\r\n        await base.onSettled?.(data, error, variables, onMutateResult, context);\r\n        await options.onSettled?.(data, error, variables, onMutateResult, context);\r\n      },\r\n    }),\r\n  };\r\n}\r\n\r\nexport function mergeQueryOptions<TData, TError, TQueryKey extends QueryKey>(\r\n  base: UseQueryOptions<TData, TError, TData, TQueryKey>,\r\n  options?: Partial<UseQueryOptions<TData, TError, TData, TQueryKey>>\r\n): UseQueryOptions<TData, TError, TData, TQueryKey> {\r\n  if (!options) return base;\r\n  return {\r\n    ...base,\r\n    ...options,\r\n  };\r\n}\r\n"
  ],
  "mappings": "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",
  "debugId": "3974E80E199B9F8064756E2164756E21",
  "names": []
}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eden2query",
   "description": "Type-safe Eden Treaty to React Query helpers",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "type": "module",
   "files": [
     "dist"
@@ -41,10 +41,12 @@
   "peerDependencies": {
     "@elysiajs/eden": "^1.4.6",
     "@tanstack/react-query": "^5.90.20",
+    "react": "^19.2.4",
     "typescript": "^5"
   },
   "devDependencies": {
     "@types/bun": "latest",
+    "@types/react": "^19.2.14",
     "bunup": "^0.16.22",
     "elysia": "^1.4.22",
     "prettier": "^3.4.2"