eden2query 0.3.8 → 0.3.10

package/README.md

@@ -1,418 +1,418 @@
-# eden2query
-
-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
-
-```bash
-bun add eden2query @elysiajs/eden @tanstack/react-query
-```
-
-## Quick Start
-
-### 1. Define your Elysia API
-
-```ts
-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() }) },
-  });
-```
-
-### 2. Create Treaty Client
-
-```ts
-import { treaty } from "@elysiajs/eden";
-
-const client = treaty<typeof app>("http://localhost:3000");
-```
-
-### 3. Create Type-Safe Hooks
-
-```ts
-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"] });
-    },
-  };
-});
-```
-
-### 4. Use in Components
-
-```tsx
-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
-
-### `treatyQueryHook`
-
-Creates a type-safe React Query hook for GET requests.
-
-**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
-```
-
-**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
-// 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
-});
-```
-
-## 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
-
-### Routes with Params
-
-For routes like `/users/:id`, params are **required** and included in the request type:
-
-```ts
-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):
-
-```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
-});
-```
-
-### Mutations with Body (no params)
-
-POST mutations without route params include a `body` field:
-
-```ts
-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
-});
-```
-
-### Mutations with Params and Body
-
-PUT mutations can have both params and body:
-
-```ts
-function updateUser(params: { id: string }) {
-  return client.api.users({ id: params.id }).put;
-}
-
-const useUpdateUser = treatyMutationHook(updateUser, () => ({}));
-
-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)
-
-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;
-}
-
-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
-});
-```
-
-## Options Merging
-
-Options are merged in this order (later options override earlier ones):
-
-1. Base options from `useOptions` hook
-2. Options passed to the hook factory
-3. Options passed when calling the hook
-
-Callbacks (`onSuccess`, `onError`, etc.) are **chained** - all callbacks run in order.
-
-## License
-
-MIT
+# eden2query
+
+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
+
+```bash
+bun add eden2query @elysiajs/eden @tanstack/react-query
+```
+
+## Quick Start
+
+### 1. Define your Elysia API
+
+```ts
+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() }) },
+  });
+```
+
+### 2. Create Treaty Client
+
+```ts
+import { treaty } from "@elysiajs/eden";
+
+const client = treaty<typeof app>("http://localhost:3000");
+```
+
+### 3. Create Type-Safe Hooks
+
+```ts
+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"] });
+    },
+  };
+});
+```
+
+### 4. Use in Components
+
+```tsx
+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
+
+### `treatyQueryHook`
+
+Creates a type-safe React Query hook for GET requests.
+
+**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
+```
+
+**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
+// 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
+});
+```
+
+## 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
+
+### Routes with Params
+
+For routes like `/users/:id`, params are **required** and included in the request type:
+
+```ts
+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):
+
+```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
+});
+```
+
+### Mutations with Body (no params)
+
+POST mutations without route params include a `body` field:
+
+```ts
+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
+});
+```
+
+### Mutations with Params and Body
+
+PUT mutations can have both params and body:
+
+```ts
+function updateUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).put;
+}
+
+const useUpdateUser = treatyMutationHook(updateUser, () => ({}));
+
+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)
+
+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;
+}
+
+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
+});
+```
+
+## Options Merging
+
+Options are merged in this order (later options override earlier ones):
+
+1. Base options from `useOptions` hook
+2. Options passed to the hook factory
+3. Options passed when calling the hook
+
+Callbacks (`onSuccess`, `onError`, etc.) are **chained** - all callbacks run in order.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Treaty } from "@elysiajs/eden";
 import { UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
-type IsEmpty<T> = [T] extends [never | undefined | void] ? true : [unknown] extends [T] ? [T] extends [unknown] ? true : false : false;
+type IsEmpty<T> = [T] extends [never | undefined | void] ? true : [unknown] extends [T] ? [T] extends [unknown] ? true : false : [T] extends [object] ? [keyof T] extends [never] ? true : false : false;
 type TreatyMutationFunctionFactory<
 	TParams,
 	TBody,
@@ -16,9 +16,13 @@ type TreatyMutationRequest<
 	TParams,
 	TBody,
 	TOption
-> = TOption & (IsEmpty<TParams> extends true ? {} : {
+> = TOption & (IsEmpty<TParams> extends true ? {
+	params?: TParams;
+} : {
 	params: TParams;
-}) & (IsEmpty<TBody> extends true ? {} : {
+}) & (IsEmpty<TBody> extends true ? {
+	body?: TBody;
+} : {
 	body: TBody;
 });
 type TreatyData<TResponse extends Record<number, unknown>> = Treaty.TreatyResponse<TResponse>["data"];
@@ -53,7 +57,9 @@ type TreatyQueryFunctionFactory<
 type TreatyQueryRequest<
 	TParams,
 	TOption extends object
-> = TOption & (IsEmpty<TParams> extends true ? {} : {
+> = TOption & (IsEmpty<TParams> extends true ? {
+	params?: TParams;
+} : {
 	params: TParams;
 });
 type TreatyQueryOptions<TResponse extends Record<number, unknown>> = UseQueryOptions<TreatyData<TResponse>, TreatyError<TResponse>>;

package/dist/index.js

@@ -48,7 +48,7 @@ function treatyMutationHook(fn, useOptions) {
       ...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 body = "body" in request && request.body !== undefined ? request.body : {};
         const { data, error } = await mutationFn(body, request);
         if (error)
           throw error;
@@ -78,5 +78,5 @@ export {
   treatyMutationHook
 };
 
-//# debugId=89C48BF36DA4F8BA64756E2164756E21
-//# 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,aAAa,KAAK,CAAC;AAAA,IACvC,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": "89C48BF36DA4F8BA64756E2164756E21",
  "names": []
}
+//# debugId=D2B04DF79F0D08F564756E2164756E21
+//# 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\" or \"no body\" (absent/empty)\r\n// Checks for never, undefined, void, unknown (unconstrained), and empty object {}\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      // Check if T is an empty object {}\r\n      : [T] extends [object]\r\n        ? [keyof T] extends [never]\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 } : { params: TParams }) &\r\n  (IsEmpty<TBody> extends true ? { body?: TBody } : { 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 default to empty object\r\n        const body = \"body\" in request && request.body !== undefined ? request.body : ({} 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 } : { 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;;;AD2CK,SAAS,kBAKf,CACC,IACA,YAIwD;AAAA,EACxD,OAAO,CAAC,YAAY;AAAA,IAClB,MAAM,cAAc,aAAa,KAAK,CAAC;AAAA,IACvC,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,CAAC;AAAA,QAChF,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": "D2B04DF79F0D08F564756E2164756E21",
  "names": []
}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eden2query",
   "description": "Type-safe Eden Treaty to React Query helpers",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "type": "module",
   "files": [
     "dist"
@@ -39,7 +39,7 @@
     "prepublishOnly": "bun run build"
   },
   "peerDependencies": {
-    "@elysiajs/eden": "^1.4.6",
+    "@elysiajs/eden": "^1.4.8",
     "@tanstack/react-query": "^5.90.20",
     "react": "^19.2.4",
     "typescript": "^5"
@@ -48,7 +48,7 @@
     "@types/bun": "latest",
     "@types/react": "^19.2.14",
     "bunup": "^0.16.22",
-    "elysia": "^1.4.22",
+    "elysia": "^1.4.25",
     "prettier": "^3.4.2"
   }
 }