eden2query 0.3.5 → 0.3.7

package/README.md

@@ -1,6 +1,6 @@
 # eden2query
 
-Type-safe [Eden Treaty](https://elysiajs.com/eden/overview) to [React Query](https://tanstack.com/query) helpers. Two functions, zero runtime dependencies.
+Type-safe [Eden Treaty](https://elysiajs.com/eden/overview) to [React Query](https://tanstack.com/query) helpers. Create fully type-safe React Query hooks from your Elysia API with zero runtime overhead.
 
 ## Install
 
@@ -8,136 +8,410 @@ Type-safe [Eden Treaty](https://elysiajs.com/eden/overview) to [React Query](htt
 bun add eden2query @elysiajs/eden @tanstack/react-query
 ```
 
-## Usage
+## Quick Start
 
-**Queries (GET)** — pass a thunk that calls the Treaty GET:
+### 1. Define your Elysia API
 
 ```ts
-const getOptions = treatyQueryOptions(
-  () => client.api.resource.get({ query: { q: "hello" } }),
-  { queryKey: ["resource"], refetchInterval: 1000 },
-);
+import Elysia, { t } from "elysia";
+
+const app = new Elysia({ prefix: "/api" })
+  .get("/users/:id", ({ params, query }) => {
+    return { user: { id: params.id, name: query.name } };
+  }, {
+    params: t.Object({ id: t.String() }),
+    query: t.Object({ name: t.String() }),
+    response: { 200: t.Object({ user: t.Object({ id: t.String(), name: t.String() }) }) },
+  })
+  .post("/users", ({ body }) => {
+    return { id: "123", ...body };
+  }, {
+    body: t.Object({ name: t.String(), email: t.String() }),
+    response: { 200: t.Object({ id: t.String(), name: t.String(), email: t.String() }) },
+  })
+  .put("/users/:id", ({ params, body }) => {
+    return { id: params.id, ...body };
+  }, {
+    params: t.Object({ id: t.String() }),
+    body: t.Object({ name: t.String() }),
+    response: { 200: t.Object({ id: t.String(), name: t.String() }) },
+  })
+  .delete("/users/:id", ({ params }) => {
+    return { deleted: params.id };
+  }, {
+    params: t.Object({ id: t.String() }),
+    response: { 200: t.Object({ deleted: t.String() }) },
+  });
 ```
 
-**Mutations with variables (POST, PUT, etc.)** — pass a function that receives the mutation input, or a bound Treaty method:
+### 2. Create Treaty Client
 
 ```ts
-// Wrapper when Treaty uses (body, options)
-const postOptions = treatyMutationOptions(
-  (vars: { body: { name: string }; query: { q: string } }) =>
-    client.api.resource.post(vars.body, { query: vars.query }),
-  { onSuccess: () => console.log("Success") },
-);
-
-// Parameterised routes — bind params first
-const putOptions = treatyMutationOptions(
-  client.api.resource({ id: "dummy" }).put,
-  { onSettled: () => console.log("Settled") },
-);
+import { treaty } from "@elysiajs/eden";
+
+const client = treaty<typeof app>("http://localhost:3000");
 ```
 
-**Mutations without variables (e.g. DELETE with fixed params)** — pass a no-argument function; `mutate()` is then called with no args:
+### 3. Create Type-Safe Hooks
 
 ```ts
-const deleteOptions = treatyMutationOptions(
-  () => client.api.resource({ id: "dummy" }).delete(),
-  { onMutate: () => console.log("Mutate") },
-);
+import { treatyQueryHook, treatyMutationHook } from "eden2query";
+import { useQueryClient } from "@tanstack/react-query";
+
+// GET - Query Hook (with params)
+function getUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).get;
+}
+
+const useGetUser = treatyQueryHook(getUser, (request) => {
+  return {
+    queryKey: ["users", request.params.id],
+  };
+});
+
+// POST - Mutation Hook
+function createUser() {
+  return client.api.users.post;
+}
+
+const useCreateUser = treatyMutationHook(createUser, () => {
+  const queryClient = useQueryClient();
+  return {
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["users"] });
+    },
+  };
+});
+
+// PUT - Mutation Hook with Params
+function updateUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).put;
+}
+
+const useUpdateUser = treatyMutationHook(updateUser, () => {
+  const queryClient = useQueryClient();
+  return {
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["users"] });
+    },
+  };
+});
+
+// DELETE - Mutation Hook with Params (no body)
+function deleteUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).delete;
+}
+
+const useDeleteUser = treatyMutationHook(deleteUser, () => {
+  const queryClient = useQueryClient();
+  return {
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["users"] });
+    },
+  };
+});
 ```
 
-Use with React Query as usual:
+### 4. Use in Components
 
 ```tsx
-const { data } = useQuery(getOptions);
+function UserProfile({ userId }: { userId: string }) {
+  // Query - automatically typed
+  const { data, isLoading } = useGetUser({
+    params: { id: userId },
+    query: { name: "John" },
+  });
+
+  // Mutations - fully typed
+  const createMutation = useCreateUser({
+    onSuccess: (data) => {
+      console.log("Created:", data);
+    },
+  });
+
+  const updateMutation = useUpdateUser({
+    onSuccess: (data) => {
+      console.log("Updated:", data);
+    },
+  });
+
+  const deleteMutation = useDeleteUser({
+    onSuccess: (data) => {
+      console.log("Deleted:", data);
+    },
+  });
+
+  return (
+    <div>
+      {isLoading ? "Loading..." : <div>{data?.user.name}</div>}
+      
+      <button onClick={() => createMutation.mutate({
+        body: { name: "New User", email: "user@example.com" },
+      })}>
+        Create User
+      </button>
+
+      <button onClick={() => updateMutation.mutate({
+        params: { id: userId },
+        body: { name: "Updated Name" },
+      })}>
+        Update User
+      </button>
+
+      <button onClick={() => deleteMutation.mutate({
+        params: { id: userId },
+        // body is not required for DELETE mutations
+      })}>
+        Delete User
+      </button>
+    </div>
+  );
+}
+```
+
+## API Reference
 
-const postMutation = useMutation(postOptions);
-postMutation.mutate({ body: { name: "World" }, query: { q: "hello" } });
+### `treatyQueryHook`
 
-const putMutation = useMutation(putOptions);
-putMutation.mutate({ name: "World" });
+Creates a type-safe React Query hook for GET requests.
 
-const deleteMutation = useMutation(deleteOptions);
-deleteMutation.mutate(); // no arguments
+**Signature:**
+```ts
+function treatyQueryHook<TParams, TOption extends object, TResponse extends Record<number, unknown>>(
+  fn: TreatyQueryFunctionFactory<TParams, TOption, TResponse>,
+  useOptions: (request: TreatyQueryRequest<TParams, TOption>) => Omit<UseQueryOptions<TResponse>, "queryFn">
+): (request: TreatyQueryRequest<TParams, TOption>, options?: UseQueryOptions) => UseQueryResult
 ```
 
-Prefetch and other helpers work as usual:
+**Parameters:**
+- `fn`: A factory function that accepts params (if route has params) or no params (if route doesn't have params), and returns a Treaty query function
+- `useOptions`: A function that receives the request and returns query options (including `queryKey`)
+
+**Returns:** A hook function that accepts a request object and optional query options
 
+**Example:**
 ```ts
-const queryClient = new QueryClient();
-queryClient.prefetchQuery(getOptions);
+// With params
+function getUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).get;
+}
+
+const useGetUser = treatyQueryHook(getUser, (request) => ({
+  queryKey: ["users", request.params.id], // params is required when route has params
+  staleTime: 5000,
+}));
+
+// Usage
+const { data } = useGetUser({
+  params: { id: "123" }, // Required when route has params
+  query: { name: "John" },
+});
+
+// Without params
+function getUsers() {
+  return client.api.users.get;
+}
+
+const useGetUsers = treatyQueryHook(getUsers, (request) => ({
+  queryKey: ["users"],
+}));
+
+// Usage - params are absent from the type
+const { data } = useGetUsers({
+  query: { page: "1" },
+  // params is not part of the request type
+});
+```
+
+### `treatyMutationHook`
+
+Creates a type-safe React Query hook for mutations (POST, PUT, DELETE, etc.).
+
+**Signature:**
+```ts
+function treatyMutationHook<TParams, TBody, TOption, TResponse extends Record<number, unknown>>(
+  fn: TreatyMutationFunctionFactory<TParams, TBody, TOption, TResponse>,
+  useOptions: () => Omit<UseMutationOptions<TParams, TBody, TOption, TResponse>, "mutationFn">
+): (options?: UseMutationOptions) => UseMutationResult
+```
+
+**Parameters:**
+- `fn`: A factory function that accepts params (if route has params) or no params (if route doesn't have params), and returns a Treaty mutation function
+- `useOptions`: A hook function that returns default mutation options (can use React hooks like `useQueryClient`)
+
+**Returns:** A hook function that accepts optional mutation options
+
+**Example:**
+```ts
+// Without params, with body
+function createUser() {
+  return client.api.users.post;
+}
+
+const useCreateUser = treatyMutationHook(createUser, () => {
+  const queryClient = useQueryClient();
+  return {
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["users"] });
+    },
+  };
+});
+
+// Usage
+const mutation = useCreateUser({
+  onSuccess: (data) => console.log(data),
+});
+
+mutation.mutate({
+  body: { name: "John", email: "john@example.com" },
+  // params is not part of the request type
+});
+
+// With params and body
+function updateUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).put;
+}
+
+const useUpdateUser = treatyMutationHook(updateUser, () => ({
+  onSuccess: () => console.log("Updated"),
+}));
+
+useUpdateUser().mutate({
+  params: { id: "123" },
+  body: { name: "Updated Name" },
+});
+
+// With params, without body
+function deleteUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).delete;
+}
+
+const useDeleteUser = treatyMutationHook(deleteUser, () => ({
+  onSuccess: () => console.log("Deleted"),
+}));
+
+useDeleteUser().mutate({
+  params: { id: "123" },
+  // body is not part of the request type
+});
 ```
 
-### Hook builders: `createTreatyQueryHook` / `createTreatyMutationHook`
+## Type Safety
+
+All types are inferred end-to-end from your Elysia route definitions:
+
+- **Request types**: Automatically inferred from route params, query, and body schemas
+  - `params` and `body` are **conditionally included** in request types - they're absent (not optional) when the route doesn't require them
+  - This means you don't need to pass `undefined` or `unknown` values - the fields simply don't exist in the type
+- **Response types**: Extracted from your response schema definitions
+- **Error types**: Typed based on your error response schemas
+- **Query keys**: Type-safe based on your request structure
+
+## Patterns
 
-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).
+### Routes with Params
 
-**Query hook** — pass the Treaty GET thunk and `useOptions` (object or function):
+For routes like `/users/:id`, params are **required** and included in the request type:
 
 ```ts
-const useResource = createTreatyQueryHook(
-  () => client.api.resource.get({ query: { q: "hello" } }),
-  { queryKey: ["resource"] },
-);
+function getUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).get;
+}
+
+const useGetUser = treatyQueryHook(getUser, (request) => ({
+  queryKey: ["users", request.params.id], // params is required here
+}));
+
+// Must provide params
+useGetUser({
+  params: { id: "123" }, // ✅ Required - params is part of the request type
+  query: { name: "John" },
+});
+```
+
+### Routes without Params
+
+For routes without params, params are **absent** from the request type (not optional):
 
-// In a component
-const { data } = useResource(); // or useResource({ refetchInterval: 1000 })
+```ts
+function getUsers() {
+  return client.api.users.get;
+}
+
+const useGetUsers = treatyQueryHook(getUsers, (request) => ({
+  queryKey: ["users"],
+}));
+
+// Params are absent from the type - you cannot include them
+useGetUsers({
+  query: { page: "1" },
+  // params is not part of the request type at all
+});
 ```
 
-**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:
+### Mutations with Body (no params)
+
+POST mutations without route params include a `body` field:
 
 ```ts
-// 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" } });
+function createUser() {
+  return client.api.users.post;
+}
+
+const useCreateUser = treatyMutationHook(createUser, () => ({}));
+
+const mutation = useCreateUser();
+mutation.mutate({
+  body: { name: "John", email: "john@example.com" },
+  // params is not part of the request type
+});
 ```
 
-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)`).
+### Mutations with Params and Body
 
-## API
+PUT mutations can have both params and body:
 
-**`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`.
+```ts
+function updateUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).put;
+}
 
-**`treatyMutationOptions(fn, mutationOptions?)`** — wraps a Treaty mutation into `mutationOptions`. Two shapes:
+const useUpdateUser = treatyMutationHook(updateUser, () => ({}));
 
-- **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`).
+const mutation = useUpdateUser();
+mutation.mutate({
+  params: { id: "123" }, // Required - params is part of the request type
+  body: { name: "Updated Name" }, // Required - body is part of the request type
+});
+```
+
+### Mutations with Only Params (no body)
 
-The optional second argument accepts all `mutationOptions` fields except `mutationFn` (e.g. `onSuccess`, `onSettled`, `onMutate`).
+DELETE mutations typically only have params, and body is **absent** from the request type:
+
+```ts
+function deleteUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).delete;
+}
 
-**`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.
+const useDeleteUser = treatyMutationHook(deleteUser, () => ({}));
+
+const mutation = useDeleteUser();
+mutation.mutate({
+  params: { id: "123" }, // Required - params is part of the request type
+  // body is not part of the request type at all
+});
+```
 
-**`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`.
+## Options Merging
 
-**`InferTreatyQueryOptions<T>`** — full `UseQueryOptions` type for a given Treaty query.
+Options are merged in this order (later options override earlier ones):
 
-**`InferTreatyMutationOptions<TVariables, TResponse>`** — full `UseMutationOptions` type for a given Treaty mutation.
+1. Base options from `useOptions` hook
+2. Options passed to the hook factory
+3. Options passed when calling the hook
 
-Data, error, and input types are inferred end-to-end from your Elysia route definitions.
+Callbacks (`onSuccess`, `onError`, etc.) are **chained** - all callbacks run in order.
 
 ## License
 

package/dist/index.d.ts

@@ -1,43 +1,70 @@
 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 IsEmpty<T> = [T] extends [never | undefined | void] ? true : [unknown] extends [T] ? [T] extends [unknown] ? true : false : false;
+type TreatyMutationFunctionFactory<
+	TParams,
+	TBody,
+	TOption,
+	TResponse extends Record<number, unknown>
+> = IsEmpty<TParams> extends true ? () => TreatyMutationFunction<TBody, TOption, TResponse> : (params: TParams) => TreatyMutationFunction<TBody, TOption, TResponse>;
+type TreatyMutationFunction<
+	TBody,
+	TOption,
+	TResponse extends Record<number, unknown>
+> = (body: TBody, options: TOption) => Promise<Treaty.TreatyResponse<TResponse>>;
+type TreatyMutationRequest<
+	TParams,
+	TBody,
+	TOption
+> = TOption & (IsEmpty<TParams> extends true ? {} : {
+	params: TParams;
+}) & (IsEmpty<TBody> extends true ? {} : {
+	body: TBody;
+});
+type TreatyData<TResponse extends Record<number, unknown>> = Treaty.TreatyResponse<TResponse>["data"];
+type TreatyError<TResponse extends Record<number, unknown>> = 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>>;
+	TParams,
+	TBody,
+	TOption,
+	TResponse extends Record<number, unknown>
+> = UseMutationOptions<TreatyData<TResponse>, TreatyError<TResponse>, TreatyMutationRequest<TParams, TBody, TOption>>;
+type TreatyMutationHook<
+	TParams,
+	TBody,
+	TOption,
+	TResponse extends Record<number, unknown>
+> = (options?: Omit<TreatyMutationOptions<TParams, TBody, TOption, TResponse>, "mutationFn">) => UseMutationResult<TreatyData<TResponse>, TreatyError<TResponse>, TreatyMutationRequest<TParams, TBody, TOption>>;
+declare function treatyMutationHook<
+	TParams,
+	TBody,
+	TOption,
+	TResponse extends Record<number, unknown>
+>(fn: TreatyMutationFunctionFactory<TParams, TBody, TOption, TResponse>, useOptions: () => Omit<TreatyMutationOptions<TParams, TBody, TOption, TResponse>, "mutationFn">): TreatyMutationHook<TParams, TBody, TOption, TResponse>;
+type TreatyQueryFunction<
+	TOption extends object,
+	TResponse extends Record<number, unknown>
+> = (options: TOption) => Promise<Treaty.TreatyResponse<TResponse>>;
+type TreatyQueryFunctionFactory<
+	TParams,
+	TOption extends object,
+	TResponse extends Record<number, unknown>
+> = IsEmpty<TParams> extends true ? () => TreatyQueryFunction<TOption, TResponse> : (params: TParams) => TreatyQueryFunction<TOption, TResponse>;
+type TreatyQueryRequest<
+	TParams,
+	TOption extends object
+> = TOption & (IsEmpty<TParams> extends true ? {} : {
+	params: TParams;
+});
 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 };
+type TreatyQueryHook<
+	TParams,
+	TOption extends object,
+	TResponse extends Record<number, unknown>
+> = (request: TreatyQueryRequest<TParams, TOption>, options?: Omit<TreatyQueryOptions<TResponse>, "queryKey" | "queryFn">) => UseQueryResult<TreatyData<TResponse>, TreatyError<TResponse>>;
+declare function treatyQueryHook<
+	TParams,
+	TOption extends object,
+	TResponse extends Record<number, unknown>
+>(fn: TreatyQueryFunctionFactory<TParams, TOption, TResponse>, useOptions: (request: TreatyQueryRequest<TParams, TOption>) => Omit<TreatyQueryOptions<TResponse>, "queryFn">): TreatyQueryHook<TParams, TOption, TResponse>;
+export { treatyQueryHook, treatyMutationHook };

package/dist/index.js

@@ -1,58 +1,82 @@
-// src/lib.ts
+// src/treaty.ts
 import {
-  mutationOptions,
-  queryOptions,
   useMutation,
   useQuery
 } from "@tanstack/react-query";
-function treatyMutationOptions(fn, options) {
-  return mutationOptions({
-    ...options,
-    mutationFn: async (variables) => {
-      const response = await (fn.length === 0 ? fn() : fn(variables));
-      const { data, error } = response;
-      if (error)
-        throw error;
-      return data;
-    }
-  });
-}
-function treatyQueryOptions(fn, options) {
-  return queryOptions({
-    ...options,
-    queryFn: async () => {
-      const response = await fn();
-      const { data, error } = response;
-      if (error)
-        throw error;
-      return data;
+
+// 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 createTreatyMutationHook(fn, useOptions) {
+
+// src/treaty.ts
+function treatyMutationHook(fn, useOptions) {
   return (options) => {
-    const initOptions = typeof useOptions === "function" ? useOptions(options) : useOptions;
+    const baseOptions = useOptions();
     return useMutation({
-      ...treatyMutationOptions(fn, initOptions),
-      ...options
+      ...mergeMutationOptions(baseOptions, options),
+      mutationFn: async (request) => {
+        const mutationFn = "params" in request && request.params !== undefined ? fn(request.params) : fn();
+        const body = "body" in request && request.body !== undefined ? request.body : undefined;
+        const { data, error } = await mutationFn(body, request);
+        if (error)
+          throw error;
+        return data;
+      }
     });
   };
 }
-function createTreatyQueryHook(fn, useOptions) {
-  return (options) => {
-    const initOptions = typeof useOptions === "function" ? useOptions(options) : useOptions;
+function treatyQueryHook(fn, useOptions) {
+  return (request, options) => {
+    const queryFn = "params" in request && request.params !== undefined ? fn(request.params) : fn();
+    const baseOptions = useOptions(request);
     return useQuery({
-      ...treatyQueryOptions(fn, initOptions),
-      ...options
+      ...options,
+      ...baseOptions,
+      queryFn: async () => {
+        const { data, error } = await queryFn(request);
+        if (error)
+          throw error;
+        return data;
+      }
     });
   };
 }
 export {
-  treatyQueryOptions,
-  treatyMutationOptions,
-  createTreatyQueryHook,
-  createTreatyMutationHook
+  treatyQueryHook,
+  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=F9298CEC88E7A7AB64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src\\treaty.ts", "src\\utils.ts"],
  "sourcesContent": [
    "import type { Treaty } from \"@elysiajs/eden\";\r\nimport {\r\n  useMutation,\r\n  useQuery,\r\n  type QueryKey,\r\n  type UseMutationOptions,\r\n  type UseMutationResult,\r\n  type UseQueryOptions,\r\n  type UseQueryResult,\r\n} from \"@tanstack/react-query\";\r\nimport { mergeMutationOptions } from \"./utils\";\r\n\r\n// Helper type to check if a type represents \"no params\" (absent/empty)\r\n// Checks for never, undefined, void, and also handles unknown when it represents an unconstrained type\r\ntype IsEmpty<T> = \r\n  // Check for never, undefined, void\r\n  [T] extends [never | undefined | void] \r\n    ? true\r\n    // Check if T is unknown (unconstrained type parameter)\r\n    : [unknown] extends [T]\r\n      ? [T] extends [unknown]\r\n        ? true\r\n        : false\r\n      : false;\r\n\r\ntype TreatyMutationFunctionFactory<\r\n  TParams,\r\n  TBody,\r\n  TOption,\r\n  TResponse extends Record<number, unknown>,\r\n> = IsEmpty<TParams> extends true\r\n  ? () => TreatyMutationFunction<TBody, TOption, TResponse> \r\n  : (params: TParams) => TreatyMutationFunction<TBody, TOption, TResponse>;\r\n\r\ntype TreatyMutationFunction<\r\n  TBody,\r\n  TOption,\r\n  TResponse extends Record<number, unknown>,\r\n> = (\r\n  body: TBody,\r\n  options: TOption,\r\n) => Promise<Treaty.TreatyResponse<TResponse>>;\r\n\r\ntype TreatyMutationRequest<\r\n  TParams,\r\n  TBody,\r\n  TOption,\r\n> = TOption &\r\n  (IsEmpty<TParams> extends true ? {} : { params: TParams }) &\r\n  (IsEmpty<TBody> extends true ? {} : { body: TBody });\r\n\r\ntype TreatyData<TResponse extends Record<number, unknown>> =\r\n  Treaty.TreatyResponse<TResponse>[\"data\"];\r\n\r\ntype TreatyError<TResponse extends Record<number, unknown>> =\r\n  Treaty.TreatyResponse<TResponse>[\"error\"];\r\n\r\ntype TreatyMutationOptions<\r\n  TParams,\r\n  TBody,\r\n  TOption,\r\n  TResponse extends Record<number, unknown>,\r\n> = UseMutationOptions<\r\n  TreatyData<TResponse>,\r\n  TreatyError<TResponse>,\r\n  TreatyMutationRequest<TParams, TBody, TOption>\r\n>;\r\n\r\ntype TreatyMutationHook<\r\n  TParams,\r\n  TBody,\r\n  TOption,\r\n  TResponse extends Record<number, unknown>,\r\n> = (\r\n  options?: Omit<\r\n    TreatyMutationOptions<TParams, TBody, TOption, TResponse>,\r\n    \"mutationFn\"\r\n  >,\r\n) => UseMutationResult<\r\n  TreatyData<TResponse>,\r\n  TreatyError<TResponse>,\r\n  TreatyMutationRequest<TParams, TBody, TOption>\r\n>;\r\n\r\nexport function treatyMutationHook<\r\n  TParams,\r\n  TBody,\r\n  TOption,\r\n  TResponse extends Record<number, unknown>,\r\n>(\r\n  fn: TreatyMutationFunctionFactory<TParams, TBody, TOption, TResponse>,\r\n  useOptions: () => Omit<\r\n    TreatyMutationOptions<TParams, TBody, TOption, TResponse>,\r\n    \"mutationFn\"\r\n  >,\r\n): TreatyMutationHook<TParams, TBody, TOption, TResponse> {\r\n  return (options) => {\r\n    const baseOptions = useOptions();\r\n    return useMutation({\r\n      ...mergeMutationOptions(baseOptions, options),\r\n      mutationFn: async (request) => {\r\n        // Handle optional params: if params exists, pass it; otherwise call fn() without args\r\n        const mutationFn =\r\n          \"params\" in request && request.params !== undefined\r\n            ? (fn as (params: TParams) => TreatyMutationFunction<TBody, TOption, TResponse>)(request.params)\r\n            : (fn as () => TreatyMutationFunction<TBody, TOption, TResponse>)();\r\n        \r\n        // Handle optional body: if body exists, pass it; otherwise pass undefined\r\n        const body = \"body\" in request && request.body !== undefined ? request.body : (undefined as TBody);\r\n        const { data, error } = await mutationFn(body, request);\r\n        if (error) throw error;\r\n        return data;\r\n      },\r\n    });\r\n  };\r\n}\r\n\r\ntype TreatyQueryFunction<\r\n  TOption extends object,\r\n  TResponse extends Record<number, unknown>,\r\n> = (options: TOption) => Promise<Treaty.TreatyResponse<TResponse>>;\r\n\r\ntype TreatyQueryFunctionFactory<\r\n  TParams,\r\n  TOption extends object,\r\n  TResponse extends Record<number, unknown>,\r\n> = IsEmpty<TParams> extends true\r\n  ? () => TreatyQueryFunction<TOption, TResponse>\r\n  : (params: TParams) => TreatyQueryFunction<TOption, TResponse>;\r\n\r\ntype TreatyQueryRequest<\r\n  TParams,\r\n  TOption extends object,\r\n> = TOption &\r\n  (IsEmpty<TParams> extends true ? {} : { params: TParams });\r\n\r\ntype TreatyQueryOptions<TResponse extends Record<number, unknown>> =\r\n  UseQueryOptions<TreatyData<TResponse>, TreatyError<TResponse>>;\r\n\r\ntype TreatyQueryHook<\r\n  TParams,\r\n  TOption extends object,\r\n  TResponse extends Record<number, unknown>,\r\n> = (\r\n  request: TreatyQueryRequest<TParams, TOption>,\r\n  options?: Omit<TreatyQueryOptions<TResponse>, \"queryKey\" | \"queryFn\">,\r\n) => UseQueryResult<TreatyData<TResponse>, TreatyError<TResponse>>;\r\n\r\nexport function treatyQueryHook<\r\n  TParams,\r\n  TOption extends object,\r\n  TResponse extends Record<number, unknown>,\r\n>(\r\n  fn: TreatyQueryFunctionFactory<TParams, TOption, TResponse>,\r\n  useOptions: (\r\n    request: TreatyQueryRequest<TParams, TOption>,\r\n  ) => Omit<TreatyQueryOptions<TResponse>, \"queryFn\">,\r\n): TreatyQueryHook<TParams, TOption, TResponse> {\r\n  return (request, options) => {\r\n    // Handle optional params: if params exists, pass it; otherwise call fn() without args\r\n    const queryFn =\r\n      \"params\" in request && request.params !== undefined\r\n        ? (fn as (params: TParams) => TreatyQueryFunction<TOption, TResponse>)(request.params)\r\n        : (fn as () => TreatyQueryFunction<TOption, TResponse>)();\r\n    const baseOptions = useOptions(request);\r\n    return useQuery({\r\n      ...options,\r\n      ...baseOptions,\r\n      queryFn: async () => {\r\n        const { data, error } = await queryFn(request);\r\n        if (error) throw error;\r\n        return data;\r\n      },\r\n    });\r\n  };\r\n}\r\n",
    "import type {\r\n  QueryKey,\r\n  UseMutationOptions,\r\n  UseQueryOptions,\r\n} 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?.(\r\n          data,\r\n          error,\r\n          variables,\r\n          onMutateResult,\r\n          context,\r\n        );\r\n      },\r\n    }),\r\n  };\r\n}\r\n"
  ],
  "mappings": ";AACA;AAAA;AAAA;AAAA;;;ACKO,SAAS,oBAAyD,CACvE,MACA,SACyD;AAAA,EACzD,IAAI,CAAC;AAAA,IAAS,OAAO;AAAA,EACrB,QAAQ,WAAW,SAAS,WAAW,aAAa,SAAS;AAAA,EAC7D,OAAO;AAAA,OACF;AAAA,OACA;AAAA,OACC,aAAa,aAAa;AAAA,MAC5B,UAAU,OAAO,WAAW,YAAY;AAAA,QACtC,MAAM,OAAO,MAAM,KAAK,WAAW,WAAW,OAAO;AAAA,QACrD,MAAM,OAAO,MAAM,QAAQ,WAAW,WAAW,OAAO;AAAA,QACxD,OAAQ,SAAS,YAAY,OAAO;AAAA;AAAA,IAExC;AAAA,OACI,cAAc,aAAa;AAAA,MAC7B,WAAW,OAAO,MAAM,WAAW,gBAAgB,YAAY;AAAA,QAC7D,MAAM,KAAK,YAAY,MAAM,WAAW,gBAAgB,OAAO;AAAA,QAC/D,MAAM,QAAQ,YAAY,MAAM,WAAW,gBAAgB,OAAO;AAAA;AAAA,IAEtE;AAAA,OACI,YAAY,aAAa;AAAA,MAC3B,SAAS,OAAO,OAAO,WAAW,gBAAgB,YAAY;AAAA,QAC5D,MAAM,KAAK,UAAU,OAAO,WAAW,gBAAgB,OAAO;AAAA,QAC9D,MAAM,QAAQ,UAAU,OAAO,WAAW,gBAAgB,OAAO;AAAA;AAAA,IAErE;AAAA,OACI,cAAc,aAAa;AAAA,MAC7B,WAAW,OAAO,MAAM,OAAO,WAAW,gBAAgB,YAAY;AAAA,QACpE,MAAM,KAAK,YAAY,MAAM,OAAO,WAAW,gBAAgB,OAAO;AAAA,QACtE,MAAM,QAAQ,YACZ,MACA,OACA,WACA,gBACA,OACF;AAAA;AAAA,IAEJ;AAAA,EACF;AAAA;;;ADsCK,SAAS,kBAKf,CACC,IACA,YAIwD;AAAA,EACxD,OAAO,CAAC,YAAY;AAAA,IAClB,MAAM,cAAc,WAAW;AAAA,IAC/B,OAAO,YAAY;AAAA,SACd,qBAAqB,aAAa,OAAO;AAAA,MAC5C,YAAY,OAAO,YAAY;AAAA,QAE7B,MAAM,aACJ,YAAY,WAAW,QAAQ,WAAW,YACrC,GAA8E,QAAQ,MAAM,IAC5F,GAA+D;AAAA,QAGtE,MAAM,OAAO,UAAU,WAAW,QAAQ,SAAS,YAAY,QAAQ,OAAQ;AAAA,QAC/E,QAAQ,MAAM,UAAU,MAAM,WAAW,MAAM,OAAO;AAAA,QACtD,IAAI;AAAA,UAAO,MAAM;AAAA,QACjB,OAAO;AAAA;AAAA,IAEX,CAAC;AAAA;AAAA;AAmCE,SAAS,eAIf,CACC,IACA,YAG8C;AAAA,EAC9C,OAAO,CAAC,SAAS,YAAY;AAAA,IAE3B,MAAM,UACJ,YAAY,WAAW,QAAQ,WAAW,YACrC,GAAoE,QAAQ,MAAM,IAClF,GAAqD;AAAA,IAC5D,MAAM,cAAc,WAAW,OAAO;AAAA,IACtC,OAAO,SAAS;AAAA,SACX;AAAA,SACA;AAAA,MACH,SAAS,YAAY;AAAA,QACnB,QAAQ,MAAM,UAAU,MAAM,QAAQ,OAAO;AAAA,QAC7C,IAAI;AAAA,UAAO,MAAM;AAAA,QACjB,OAAO;AAAA;AAAA,IAEX,CAAC;AAAA;AAAA;",
  "debugId": "F9298CEC88E7A7AB64756E2164756E21",
  "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.7",
   "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"