eden2query 0.2.0 → 0.3.1

package/README.md

@@ -10,69 +10,79 @@ bun add eden2query @elysiajs/eden @tanstack/react-query
 
 ## Usage
 
-```ts
-import { treaty } from "@elysiajs/eden";
-import { edenQueryOptions, edenMutationOptions } 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 Eden GET function)
-const resourceQuery = edenQueryOptions(
+```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 = edenMutationOptions(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 = edenMutationOptions(
-  client.api.resource({ id: "some-id" }).put,
+const putOptions = treatyMutationOptions(
+  client.api.resource({ id: "dummy" }).put,
+  { onSettled: () => console.log("Settled") },
+);
+```
+
+**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") },
 );
 ```
 
-Then use them with React Query as usual:
+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 = edenQueryOptions(
-  () => client.api.resource.get({ query: { q: "hello" } }),
-  { queryKey: ["resource"], refetchInterval: 1000 },
-);
-
-const createResource = edenMutationOptions(
-  client.api.resource.post,
-  { onSuccess: () => console.log("created!") },
-);
+const queryClient = new QueryClient();
+queryClient.prefetchQuery(getOptions);
 ```
 
 ## API
 
-**`edenQueryOptions(fn, queryOptions)`** — wraps an Eden GET call into `queryOptions`. `fn` is a **thunk** (zero-argument function) that calls the Eden GET function, e.g. `() => client.api.resource.get({ query: { ... } })`. This lets you bind query parameters, headers, or any other Eden 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`).
 
-**`edenMutationOptions(fn, mutationOptions?)`** — wraps an Eden 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 Eden options (like `query`) as the input.
+The optional second argument accepts all `mutationOptions` fields except `mutationFn` (e.g. `onSuccess`, `onSettled`, `onMutate`).
 
-**`InferQueryOptions<TFn>`** — extracts the full `UseQueryOptions` type for a given Eden GET thunk.
+**`InferTreatyQueryOptions<T>`** — full `UseQueryOptions` type for a given Treaty query.
 
-**`InferMutationOptions<TFn>`** — extracts the full `UseMutationOptions` type for a given Eden 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 EdenMutationFn<
-	TBody = any,
-	TOptions = any,
-	TResponse extends Record<number, unknown> = Record<number, unknown>
-> = ((body: TBody, options: TOptions) => Promise<Treaty.TreatyResponse<TResponse>>);
-type EdenQueryFn<TResponse extends Record<number, unknown> = Record<number, unknown>> = (() => Promise<Treaty.TreatyResponse<TResponse>>);
-type InferMutationVariables<TFn extends EdenMutationFn> = (unknown extends Parameters<TFn>[0] ? Parameters<TFn>[1] : Parameters<TFn>[1] & {
-	body: Parameters<TFn>[0];
-});
-type InferMutationOptions<TFn extends EdenMutationFn> = (UseMutationOptions<Awaited<ReturnType<TFn>>["data"], Awaited<ReturnType<TFn>>["error"], InferMutationVariables<TFn>>);
-type InferQueryOptions<TFn extends EdenQueryFn> = (UseQueryOptions<Awaited<ReturnType<TFn>>["data"], Awaited<ReturnType<TFn>>["error"]>);
-declare function edenMutationOptions<TFn extends EdenMutationFn>(fn: TFn, options?: Omit<InferMutationOptions<TFn>, "mutationFn">): InferMutationOptions<TFn>;
-declare function edenQueryOptions<TFn extends EdenQueryFn>(fn: TFn, options: Omit<InferQueryOptions<TFn>, "queryFn">): InferQueryOptions<TFn>;
-export { edenQueryOptions, edenMutationOptions, InferQueryOptions, InferMutationOptions };
+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 InferTreatyData<TResponse extends TreatyResponse> = Treaty.TreatyResponse<TResponse>["data"];
+type InferTreatyError<TResponse extends TreatyResponse> = Treaty.TreatyResponse<TResponse>["error"];
+type InferTreatyMutationOptions<
+	TInput,
+	TResponse extends TreatyResponse
+> = UseMutationOptions<InferTreatyData<TResponse>, InferTreatyError<TResponse>, TInput>;
+type InferTreatyQueryOptions<TResponse extends Record<number, unknown>> = UseQueryOptions<InferTreatyData<TResponse>, InferTreatyError<TResponse>>;
+declare function treatyMutationOptions<TResponse extends TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, options?: Omit<InferTreatyMutationOptions<void, TResponse>, "mutationFn">): InferTreatyMutationOptions<void, TResponse>;
+declare function treatyMutationOptions<
+	TVariables,
+	TResponse extends TreatyResponse
+>(fn: TreatyFunctionWithParams<TVariables, TResponse>, options?: Omit<InferTreatyMutationOptions<TVariables, TResponse>, "mutationFn">): InferTreatyMutationOptions<TVariables, TResponse>;
+declare function treatyQueryOptions<TResponse extends TreatyResponse = TreatyResponse>(fn: TreatyFunctionWithoutParams<TResponse>, options: Omit<InferTreatyQueryOptions<TResponse>, "queryFn">): InferTreatyQueryOptions<TResponse>;
+export { treatyQueryOptions, treatyMutationOptions, TreatyFunctionWithoutParams as TreatyQueryFunction, TreatyFunctionWithParams as TreatyMutationFunction, InferTreatyQueryOptions, InferTreatyMutationOptions, InferTreatyError, InferTreatyData };

package/dist/index.js

@@ -1,34 +1,36 @@
 // src/lib.ts
-import { mutationOptions, queryOptions } from "@tanstack/react-query";
-function edenMutationOptions(fn, options) {
+import {
+  mutationOptions,
+  queryOptions
+} from "@tanstack/react-query";
+function treatyMutationOptions(fn, options) {
   return mutationOptions({
+    ...options,
     mutationFn: async (variables) => {
-      const { body, ...rest } = variables;
-      const response = await fn(body, rest);
+      const response = await (fn.length === 0 ? fn() : fn(variables));
       const { data, error } = response;
       if (error)
         throw error;
       return data;
-    },
-    ...options
+    }
   });
 }
-function edenQueryOptions(fn, options) {
+function treatyQueryOptions(fn, options) {
   return queryOptions({
+    ...options,
     queryFn: async () => {
       const response = await fn();
       const { data, error } = response;
       if (error)
         throw error;
       return data;
-    },
-    ...options
+    }
   });
 }
 export {
-  edenQueryOptions,
-  edenMutationOptions
+  treatyQueryOptions,
+  treatyMutationOptions
 };
 
-//# debugId=536B0B1CEFDDC08764756E2164756E21
-//# 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.2.0",
+  "version": "0.3.1",
   "type": "module",
   "files": [
     "dist"
@@ -35,6 +35,7 @@
   ],
   "scripts": {
     "build": "bunup",
+    "format": "prettier --write .",
     "prepublishOnly": "bun run build"
   },
   "peerDependencies": {
@@ -45,6 +46,7 @@
   "devDependencies": {
     "@types/bun": "latest",
     "bunup": "^0.16.22",
-    "elysia": "^1.4.22"
+    "elysia": "^1.4.22",
+    "prettier": "^3.4.2"
   }
 }