eden2query 0.3.0 → 0.3.2

package/README.md

@@ -10,68 +10,79 @@ bun add eden2query @elysiajs/eden @tanstack/react-query
 
 ## Usage
 
-```ts
-import { treaty } from "@elysiajs/eden";
-import { treatyQueryOptions, treatyMutationOptions } from "eden2query";
-import type { App } from "./server"; // your Elysia app type
-
-const client = treaty<App>("localhost:3000");
+**Queries (GET)** — pass a thunk that calls the Treaty GET:
 
-// GET → queryOptions (first arg is a thunk that calls the Treaty GET function)
-const resourceQuery = treatyQueryOptions(
+```ts
+const getOptions = treatyQueryOptions(
   () => client.api.resource.get({ query: { q: "hello" } }),
-  { queryKey: ["resource"] },
+  { queryKey: ["resource"], refetchInterval: 1000 },
 );
+```
+
+**Mutations with variables (POST, PUT, etc.)** — pass a function that receives the mutation input, or a bound Treaty method:
 
-// POST / PUT / DELETE → mutationOptions
-const createResource = treatyMutationOptions(client.api.resource.post);
+```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 updateResource = treatyMutationOptions(
-  client.api.resource({ id: "some-id" }).put,
+const putOptions = treatyMutationOptions(
+  client.api.resource({ id: "dummy" }).put,
+  { onSettled: () => console.log("Settled") },
 );
 ```
 
-Then use them with React Query as usual:
+**Mutations without variables (e.g. DELETE with fixed params)** — pass a no-argument function; `mutate()` is then called with no args:
+
+```ts
+const deleteOptions = treatyMutationOptions(
+  () => client.api.resource({ id: "dummy" }).delete(),
+  { onMutate: () => console.log("Mutate") },
+);
+```
+
+Use with React Query as usual:
 
 ```tsx
-const { data } = useQuery(resourceQuery);
-const mutation = useMutation(createResource);
+const { data } = useQuery(getOptions);
 
-mutation.mutate({ body: { name: "New item" }, query: { q: "hello" } }); // fully typed input
-```
+const postMutation = useMutation(postOptions);
+postMutation.mutate({ body: { name: "World" }, query: { q: "hello" } });
 
-Works with `prefetchQuery`, `ensureQueryData`, `useSuspenseQuery`, etc:
+const putMutation = useMutation(putOptions);
+putMutation.mutate({ name: "World" });
 
-```ts
-const queryClient = new QueryClient();
-await queryClient.prefetchQuery(resourceQuery);
+const deleteMutation = useMutation(deleteOptions);
+deleteMutation.mutate(); // no arguments
 ```
 
-You can also pass any standard React Query options as the second argument:
+Prefetch and other helpers work as usual:
 
 ```ts
-const resourceQuery = treatyQueryOptions(
-  () => client.api.resource.get({ query: { q: "hello" } }),
-  { queryKey: ["resource"], refetchInterval: 1000 },
-);
-
-const createResource = treatyMutationOptions(client.api.resource.post, {
-  onSuccess: () => console.log("created!"),
-});
+const queryClient = new QueryClient();
+queryClient.prefetchQuery(getOptions);
 ```
 
 ## API
 
-**`treatyQueryOptions(fn, queryOptions)`** — wraps a Treaty GET call into `queryOptions`. `fn` is a **thunk** (zero-argument function) that calls the Treaty GET function, e.g. `() => client.api.resource.get({ query: { ... } })`. This lets you bind query parameters, headers, or any other Treaty options at definition time. The second argument accepts all `queryOptions` fields except `queryFn`. Extracts `data` from the response and throws on `error`.
+**`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`.
+
+**`treatyMutationOptions(fn, mutationOptions?)`** — wraps a Treaty mutation into `mutationOptions`. Two shapes:
+
+- **No-arg:** `fn` is `() => Promise<...>`. Use when the mutation has no call-time input (e.g. DELETE with fixed path params). `mutate()` is called with no arguments.
+- **With variables:** `fn` is `(vars) => Promise<...>`. Use for POST/PUT etc. `mutate(vars)` receives a single object (e.g. `{ body, query }` or the Treaty method’s first argument). You can pass the Treaty method directly when its signature matches (e.g. `client.api.resource({ id }).put`).
 
-**`treatyMutationOptions(fn, mutationOptions?)`** — wraps a Treaty mutation function into `mutationOptions`. The optional second argument accepts all `mutationOptions` fields except `mutationFn` (e.g. `onSuccess`, `onSettled`, `onMutate`). The `mutate` call receives a single object with `body` and any other Treaty options (like `query`) as the input.
+The optional second argument accepts all `mutationOptions` fields except `mutationFn` (e.g. `onSuccess`, `onSettled`, `onMutate`).
 
-**`InferTreatyQueryOptions<T>`** — extracts the full `UseQueryOptions` type for a given Treaty query function.
+**`InferTreatyQueryOptions<T>`** — full `UseQueryOptions` type for a given Treaty query.
 
-**`InferTreatyMutationOptions<T>`** — extracts the full `UseMutationOptions` type for a given Treaty mutation function.
+**`InferTreatyMutationOptions<TVariables, TResponse>`** — full `UseMutationOptions` type for a given Treaty mutation.
 
-All helpers infer data, error, and input types end-to-end from your Elysia route definitions. No manual generics needed.
+Data, error, and input types are inferred end-to-end from your Elysia route definitions.
 
 ## License
 

package/dist/index.d.ts

@@ -1,16 +1,22 @@
 import { Treaty } from "@elysiajs/eden";
 import { UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
-type AnyResponse = Record<number, unknown>;
-type TreatyMutationFunction<
-	TArgs = unknown,
-	TResponse extends AnyResponse = AnyResponse
-> = (args: TArgs) => Promise<Treaty.TreatyResponse<TResponse>>;
-type TreatyQueryFunction<TResponse extends AnyResponse = AnyResponse> = () => Promise<Treaty.TreatyResponse<TResponse>>;
-type InferTreatyData<T extends TreatyMutationFunction | TreatyQueryFunction> = Awaited<ReturnType<T>>["data"];
-type InferTreatyError<T extends TreatyMutationFunction | TreatyQueryFunction> = Awaited<ReturnType<T>>["error"];
-type InferTreatyVariables<T extends TreatyMutationFunction> = Parameters<T> extends [] ? void : Parameters<T>[0];
-type InferTreatyMutationOptions<T extends TreatyMutationFunction> = UseMutationOptions<InferTreatyData<T>, InferTreatyError<T>, InferTreatyVariables<T>>;
-type InferTreatyQueryOptions<T extends TreatyQueryFunction> = UseQueryOptions<InferTreatyData<T>, InferTreatyError<T>>;
-declare function treatyMutationOptions<T extends TreatyMutationFunction>(fn: T, options: Omit<InferTreatyMutationOptions<T>, "mutationFn">): InferTreatyMutationOptions<T>;
-declare function treatyQueryOptions<T extends TreatyQueryFunction>(fn: T, options: Omit<InferTreatyQueryOptions<T>, "queryFn">): InferTreatyQueryOptions<T>;
-export { treatyQueryOptions, treatyMutationOptions, TreatyQueryFunction, TreatyMutationFunction, InferTreatyVariables, InferTreatyQueryOptions, InferTreatyMutationOptions, InferTreatyError, InferTreatyData };
+type TreatyResponse = Record<number, unknown>;
+type TreatyFunctionWithoutParams<TResponse extends TreatyResponse = TreatyResponse> = () => Promise<Treaty.TreatyResponse<TResponse>>;
+type TreatyFunctionWithParams<
+	TParams,
+	TResponse extends TreatyResponse
+> = (params: TParams) => Promise<Treaty.TreatyResponse<TResponse>>;
+type TreatyData<TResponse extends TreatyResponse> = Treaty.TreatyResponse<TResponse>["data"];
+type TreatyError<TResponse extends TreatyResponse> = Treaty.TreatyResponse<TResponse>["error"];
+type TreatyMutationOptions<
+	TVariables,
+	TResponse extends TreatyResponse
+> = UseMutationOptions<TreatyData<TResponse>, TreatyError<TResponse>, TVariables>;
+type TreatyQueryOptions<TResponse extends Record<number, unknown>> = UseQueryOptions<TreatyData<TResponse>, TreatyError<TResponse>>;
+declare function treatyMutationOptions<TResponse extends TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, options?: Omit<TreatyMutationOptions<void, TResponse>, "mutationFn">): TreatyMutationOptions<void, TResponse>;
+declare function treatyMutationOptions<
+	TVariables,
+	TResponse extends TreatyResponse
+>(fn: TreatyFunctionWithParams<TVariables, TResponse>, options?: Omit<TreatyMutationOptions<TVariables, TResponse>, "mutationFn">): TreatyMutationOptions<TVariables, TResponse>;
+declare function treatyQueryOptions<TResponse extends TreatyResponse = TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, options: Omit<TreatyQueryOptions<TResponse>, "queryFn">): TreatyQueryOptions<TResponse>;
+export { treatyQueryOptions, treatyMutationOptions, TreatyQueryOptions, TreatyMutationOptions, TreatyError, TreatyData };

package/dist/index.js

@@ -7,7 +7,7 @@ function treatyMutationOptions(fn, options) {
   return mutationOptions({
     ...options,
     mutationFn: async (variables) => {
-      const response = await fn(variables);
+      const response = await (fn.length === 0 ? fn() : fn(variables));
       const { data, error } = response;
       if (error)
         throw error;
@@ -32,5 +32,5 @@ export {
   treatyMutationOptions
 };
 
-//# debugId=1F341F776DA068AF64756E2164756E21
-//# sourceMappingURL=data:application/json;base64,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
+//# debugId=668F4CB9D073178564756E2164756E21
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

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