eden-tanstack-query 0.0.9 → 0.1.0-alpha.2

package/dist/index.d.ts

@@ -1,112 +1,84 @@
-import * as _elysiajs_eden from '@elysiajs/eden';
-import { EdenFetchError } from '@elysiajs/eden';
-import { QueryFilters, QueryKey, QueryObserverOptions, QueryFunctionContext, MutationOptions, InfiniteQueryObserverOptions } from '@tanstack/query-core';
-import { Elysia } from 'elysia';
+import { Elysia, ELYSIA_FORM_DATA } from 'elysia';
+import { QueryKey, QueryClient } from '@tanstack/query-core';
+export { QueryClient, QueryKey } from '@tanstack/query-core';
 import { Treaty } from '@elysiajs/eden/treaty2';
-export { Treaty, treaty } from '@elysiajs/eden/treaty2';
 
-type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head' | 'options';
-interface EdenThrowOnErrorContext {
-    queryKey: readonly unknown[];
-    status: number;
-    method: HTTPMethod;
-    path: string[];
-    input: unknown;
+type IsNever<T> = [T] extends [never] ? true : false;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N ? Acc[number] : Enumerate<N, [...Acc, Acc['length']]>;
+type IntegerRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>>;
+type SuccessCodeRange = IntegerRange<200, 300>;
+type ExtractData<Res extends Record<number, unknown>> = Res[Extract<keyof Res, SuccessCodeRange>] extends {
+    [ELYSIA_FORM_DATA]: infer Data;
+} ? Data : Res[Extract<keyof Res, SuccessCodeRange>];
+type ExtractError<Res extends Record<number, unknown>> = Exclude<keyof Res, SuccessCodeRange> extends never ? {
+    status: unknown;
+    value: unknown;
+} : {
+    [Status in keyof Res]: {
+        status: Status;
+        value: Res[Status] extends {
+            [ELYSIA_FORM_DATA]: infer Data;
+        } ? Data : Res[Status];
+    };
+}[Exclude<keyof Res, SuccessCodeRange>];
+interface TQParamBase {
+    fetch?: RequestInit;
 }
-type EdenThrowOnError = ((queryKey: readonly unknown[], status: number) => boolean) | ((context: EdenThrowOnErrorContext) => boolean);
-/** Union type for throwOnError config option */
-type ThrowOnErrorOption = boolean | EdenThrowOnError;
-interface EdenErrorContext {
-    error: _elysiajs_eden.EdenFetchError;
-    queryKey: readonly unknown[];
-    method: HTTPMethod;
-    path: string[];
-    input: unknown;
-    type: 'query' | 'mutation';
+type SerializeQueryParams<T> = T extends Record<string, any> ? {
+    [K in keyof T]: T[K] extends Date ? string : T[K] extends Date | undefined ? string | undefined : T[K];
+} : T;
+type IsEmptyObject<T> = T extends Record<string, never> ? [keyof T] extends [never] ? true : false : false;
+type MaybeEmptyObject<T, K extends PropertyKey> = [T] extends [never] ? {} : [T] extends [undefined] ? {
+    [P in K]?: T;
+} : IsEmptyObject<T> extends true ? {
+    [P in K]?: T;
+} : undefined extends T ? {
+    [P in K]?: T;
+} : {
+    [P in K]: T;
+};
+type TQMethodParam<Body, Headers, Query, Params> = MaybeEmptyObject<Headers, 'headers'> & MaybeEmptyObject<SerializeQueryParams<Query>, 'query'> & MaybeEmptyObject<Params, 'params'> & MaybeEmptyObject<Body, 'body'> & TQParamBase;
+interface EdenQueryOptions<TData = unknown, TError = unknown> {
+    queryKey: QueryKey;
+    queryFn: () => Promise<TData>;
 }
-interface EdenQueryConfig<TThrowOnError extends ThrowOnErrorOption = true> {
-    throwOnError?: TThrowOnError;
-    queryKeyPrefix?: string | string[];
-    onError?: (context: EdenErrorContext) => void;
+interface EdenMutationOptions<TData = unknown, TError = unknown, TVariables = unknown> {
+    mutationKey: QueryKey;
+    mutationFn: (variables: TVariables) => Promise<TData>;
 }
-/**
- * Narrows data type by excluding error-shaped objects when throwOnError is true.
- * When throwOnError is true, errors are thrown before reaching callbacks like
- * `select` or `onSuccess`, so the data type should exclude error shapes.
- *
- * Uses conditional type to check if each union member has an `error: string` property,
- * which handles cases like `{ error: string; message?: undefined }` that simple
- * `Exclude<T, { error: string }>` misses due to structural typing quirks.
- */
-type NarrowedData<TData, TThrowOnError> = TThrowOnError extends true ? TData extends {
-    error: string;
-} ? never : TData : TData;
-interface EdenOptions<TEden = unknown> {
-    eden?: TEden;
+interface EdenTQMethod<Body, Headers, Query, Params, Res extends Record<number, unknown>> {
+    <TQueryFnData = ExtractData<Res>>(input: TQMethodParam<Body, Headers, Query, Params>, options?: RequestInit): Promise<Treaty.TreatyResponse<Res>>;
+    queryKey(input?: TQMethodParam<Body, Headers, Query, Params>): QueryKey;
+    queryOptions<TData = ExtractData<Res>>(input: TQMethodParam<Body, Headers, Query, Params>, overrides?: Partial<EdenQueryOptions<TData, ExtractError<Res>>>): EdenQueryOptions<TData, ExtractError<Res>>;
+    mutationKey(input?: TQMethodParam<Body, Headers, Query, Params>): QueryKey;
+    mutationOptions<TData = ExtractData<Res>>(overrides?: Partial<EdenMutationOptions<TData, ExtractError<Res>, TQMethodParam<Body, Headers, Query, Params>>>): EdenMutationOptions<TData, ExtractError<Res>, TQMethodParam<Body, Headers, Query, Params>>;
+    invalidate(queryClient: QueryClient, input?: TQMethodParam<Body, Headers, Query, Params>, exact?: boolean): Promise<void>;
 }
-type EdenQueryKey<TInput = unknown, TMethod extends HTTPMethod = HTTPMethod> = readonly [...string[], TInput, TMethod];
-/**
- * Options for eden queries, extending QueryObserverOptions.
- * Used for the optional `options` parameter in `queryOptions()`.
- */
-type EdenQueryOptions<TQueryFnData, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TEden = unknown> = Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'queryKey' | 'queryFn'> & EdenOptions<TEden>;
-/**
- * Full query options returned by `queryOptions()`, compatible with createQuery.
- * This type uses a simpler structure to ensure TypeScript properly infers TData
- * when passed to createQuery.
- */
-type EdenQueryOptionsResult<TQueryFnData, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = {
-    queryKey: TQueryKey;
-    queryFn: (context: QueryFunctionContext<TQueryKey>) => Promise<TQueryFnData>;
-} & Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'queryKey' | 'queryFn'>;
-type EdenMutationOptions<TData, TError = Error, TVariables = void, TContext = unknown, TEden = unknown> = Omit<MutationOptions<TData, TError, TVariables, TContext>, 'mutationFn'> & EdenOptions<TEden>;
-type EdenInfiniteQueryOptions<TQueryFnData, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown, TEden = unknown> = Omit<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey' | 'queryFn'> & EdenOptions<TEden>;
-type EdenPartial<T> = T extends object ? Partial<T> : never;
-type AwaitedReturn<T> = T extends (...args: any[]) => infer R ? Awaited<R> : never;
-type FirstArg<T> = T extends (arg1: infer A, ...args: any[]) => any ? A : never;
-type SecondArg<T> = T extends (arg1: any, arg2: infer B, ...args: any[]) => any ? B : never;
-type EdenData<T> = Extract<AwaitedReturn<T>, {
-    error: null;
-}> extends {
-    data: infer D;
-} ? D : never;
-type EdenQueryMethod<TMethod extends Extract<HTTPMethod, 'get' | 'head'>, TCall extends (...args: any[]) => Promise<any>, TThrowOnError extends ThrowOnErrorOption = true> = TCall & {
-    queryKey: (input?: FirstArg<TCall>) => EdenQueryKey<FirstArg<TCall>, TMethod>;
-    queryFilter: (input?: FirstArg<TCall>) => QueryFilters<EdenQueryKey<FirstArg<TCall>, TMethod>>;
-    queryOptions: (input?: FirstArg<TCall>, options?: EdenQueryOptions<NarrowedData<EdenData<TCall>, TThrowOnError>, EdenFetchError | Error, NarrowedData<EdenData<TCall>, TThrowOnError>, EdenQueryKey<FirstArg<TCall>, TMethod>, EdenPartial<NonNullable<FirstArg<TCall>>>>) => EdenQueryOptionsResult<NarrowedData<EdenData<TCall>, TThrowOnError>, EdenFetchError | Error, NarrowedData<EdenData<TCall>, TThrowOnError>, EdenQueryKey<FirstArg<TCall>, TMethod>>;
-};
-type EdenMutationMethod<TMethod extends Extract<HTTPMethod, 'post' | 'put' | 'patch' | 'delete'>, TCall extends (...args: any[]) => Promise<any>, TThrowOnError extends ThrowOnErrorOption = true> = TCall & {
-    mutationOptions: (options?: EdenMutationOptions<NarrowedData<EdenData<TCall>, TThrowOnError>, EdenFetchError | Error, FirstArg<TCall>, unknown, EdenPartial<NonNullable<SecondArg<TCall>>>>) => EdenMutationOptions<NarrowedData<EdenData<TCall>, TThrowOnError>, EdenFetchError | Error, FirstArg<TCall>, unknown, EdenPartial<NonNullable<SecondArg<TCall>>>> & {
-        mutationKey: EdenQueryKey<undefined, TMethod>;
-        mutationFn: (variables: FirstArg<TCall>) => Promise<NarrowedData<EdenData<TCall>, TThrowOnError>>;
+declare namespace EdenTQ {
+    export type Config = Treaty.Config & {
+        queryKeyPrefix?: QueryKey;
     };
-};
-type EdenQueryify<T, TThrowOnError extends ThrowOnErrorOption = true> = (T extends (...args: infer A) => infer R ? (...args: A) => EdenQueryify<R, TThrowOnError> : unknown) & (T extends object ? {
-    [K in keyof T]: EdenQueryifyValue<K, T[K], TThrowOnError>;
-} : unknown);
-type EdenQueryifyValue<K, V, TThrowOnError extends ThrowOnErrorOption = true> = K extends 'get' | 'head' ? V extends (...args: any[]) => Promise<any> ? EdenQueryMethod<Extract<K, 'get' | 'head'>, V, TThrowOnError> : V : K extends 'post' | 'put' | 'patch' | 'delete' ? V extends (...args: any[]) => Promise<any> ? EdenMutationMethod<Extract<K, 'post' | 'put' | 'patch' | 'delete'>, V, TThrowOnError> : V : EdenQueryify<V, TThrowOnError>;
+    export type Create<App extends Elysia<any, any, any, any, any, any, any>> = App extends {
+        '~Routes': infer Schema extends Record<any, any>;
+    } ? Prettify<Sign<Schema>> & CreateParams<Schema> : 'Please install Elysia before using Eden';
+    export type Sign<in out Route extends Record<any, any>> = {
+        [K in keyof Route as K extends `:${string}` ? never : K]: Route[K] extends {
+            body: infer Body;
+            headers: infer Headers;
+            params: infer Params;
+            query: infer Query;
+            response: infer Res extends Record<number, unknown>;
+        } ? EdenTQMethod<Body, Headers, Query, Params, Res> : CreateParams<Route[K]>;
+    };
+    type CreateParams<Route extends Record<string, any>> = Extract<keyof Route, `:${string}`> extends infer Path extends string ? IsNever<Path> extends true ? Prettify<Sign<Route>> : (((params: {
+        [param in Path extends `:${infer Param}` ? Param extends `${infer P}?` ? P : Param : never]: string | number;
+    }) => Prettify<Sign<Route[Path]>> & CreateParams<Route[Path]>) & Prettify<Sign<Route>>) & (Path extends `:${string}?` ? CreateParams<Route[Path]> : {}) : never;
+    export {  };
+}
 
-/**
- * Creates an Eden Query client with TanStack Query integration.
- *
- * @typeParam App - Your Elysia application type
- * @typeParam TThrowOnError - Whether to throw on errors (inferred from options, defaults to true)
- *
- * When `throwOnError` is `true` (default), error-shaped objects are excluded from
- * the data type in callbacks like `select` and `onSuccess`, since errors are thrown
- * before reaching those callbacks.
- *
- * @example
- * ```typescript
- * // Default: throwOnError = true, data types exclude error shapes
- * const eden = createEdenQuery<App>('http://localhost:8080')
- *
- * // Explicit: throwOnError = false, data types include full union
- * const eden = createEdenQuery<App>('http://localhost:8080', { throwOnError: false })
- * ```
- */
-declare function createEdenQuery<App extends Elysia<any, any, any, any, any, any, any>, const TThrowOnError extends ThrowOnErrorOption = true>(domain: string, options?: EdenQueryConfig<TThrowOnError> & {
-    treaty?: Treaty.Config;
-}): EdenQueryify<Treaty.Create<App>, TThrowOnError>;
+declare function createEdenTQ<const App extends Elysia<any, any, any, any, any, any, any>>(domain: string | App, config?: EdenTQ.Config): EdenTQ.Create<App>;
 
-export { type EdenErrorContext, type EdenInfiniteQueryOptions, type EdenMutationMethod, type EdenMutationOptions, type EdenOptions, type EdenQueryConfig, type EdenQueryKey, type EdenQueryMethod, type EdenQueryOptions, type EdenQueryOptionsResult, type EdenQueryify, type EdenThrowOnError, type EdenThrowOnErrorContext, type HTTPMethod, type NarrowedData, type ThrowOnErrorOption, createEdenQuery };
+export { type EdenMutationOptions, type EdenQueryOptions, EdenTQ, createEdenTQ };

package/dist/index.js

@@ -1,226 +1 @@
-// src/index.ts
-import { treaty } from "@elysiajs/eden/treaty2";
-
-// src/query-options.ts
-import { EdenFetchError } from "@elysiajs/eden";
-
-// src/query-key.ts
-function buildQueryKey(paths, input, method, prefix) {
-  if (prefix) {
-    return typeof prefix === "string" ? [prefix, ...paths, input, method] : [...prefix, ...paths, input, method];
-  }
-  return [...paths, input, method];
-}
-
-// src/query-options.ts
-function shouldThrowOnError(config, context) {
-  if (typeof config.throwOnError === "boolean") return config.throwOnError;
-  if (typeof config.throwOnError === "function") {
-    const fn = config.throwOnError;
-    return fn.length >= 2 ? fn(
-      context.queryKey,
-      context.status
-    ) : fn(context);
-  }
-  return true;
-}
-function toEdenFetchError(error, status) {
-  if (error instanceof EdenFetchError) return error;
-  if (error && typeof error === "object" && "value" in error) {
-    return new EdenFetchError(status, error.value);
-  }
-  return new EdenFetchError(status, error);
-}
-function createQueryOptions(treatyCall, paths, method, globalConfig) {
-  return (input, options) => {
-    const eden = options?.eden;
-    const finalInput = input === void 0 && eden === void 0 ? void 0 : { ...input, ...eden };
-    const queryKey = buildQueryKey(
-      paths,
-      finalInput,
-      method,
-      globalConfig.queryKeyPrefix
-    );
-    const { eden: _eden, ...tanstackOptions } = options ?? {};
-    return {
-      ...tanstackOptions,
-      queryKey,
-      queryFn: async (_context) => {
-        const result = await treatyCall(finalInput);
-        if (result.error) {
-          const error = toEdenFetchError(result.error, result.status);
-          error.queryKey = queryKey;
-          error.method = method;
-          error.path = paths;
-          error.input = finalInput;
-          error.response = result.response;
-          error.headers = result.headers;
-          globalConfig.onError?.({
-            error,
-            queryKey,
-            method,
-            path: paths,
-            input: finalInput,
-            type: "query"
-          });
-          if (shouldThrowOnError(globalConfig, {
-            queryKey,
-            status: result.status,
-            method,
-            path: paths,
-            input: finalInput
-          })) {
-            throw error;
-          }
-          return null;
-        }
-        return result.data;
-      }
-    };
-  };
-}
-
-// src/mutation-options.ts
-import { EdenFetchError as EdenFetchError2 } from "@elysiajs/eden";
-function shouldThrowOnError2(config, context) {
-  if (typeof config.throwOnError === "boolean") return config.throwOnError;
-  if (typeof config.throwOnError === "function") {
-    const fn = config.throwOnError;
-    return fn.length >= 2 ? fn(
-      context.queryKey,
-      context.status
-    ) : fn(context);
-  }
-  return true;
-}
-function toEdenFetchError2(error, status) {
-  if (error instanceof EdenFetchError2) return error;
-  if (error && typeof error === "object" && "value" in error) {
-    return new EdenFetchError2(status, error.value);
-  }
-  return new EdenFetchError2(status, error);
-}
-function createMutationOptions(treatyCall, paths, method, globalConfig) {
-  return (options) => {
-    const eden = options?.eden;
-    const mutationKey = buildQueryKey(
-      paths,
-      void 0,
-      method,
-      globalConfig.queryKeyPrefix
-    );
-    const { eden: _eden, ...tanstackOptions } = options ?? {};
-    return {
-      ...tanstackOptions,
-      mutationKey,
-      mutationFn: async (variables) => {
-        const result = await treatyCall(variables, eden);
-        if (result.error) {
-          const error = toEdenFetchError2(result.error, result.status);
-          error.queryKey = mutationKey;
-          error.method = method;
-          error.path = paths;
-          error.input = variables;
-          error.response = result.response;
-          error.headers = result.headers;
-          globalConfig.onError?.({
-            error,
-            queryKey: mutationKey,
-            method,
-            path: paths,
-            input: variables,
-            type: "mutation"
-          });
-          if (shouldThrowOnError2(globalConfig, {
-            queryKey: mutationKey,
-            status: result.status,
-            method,
-            path: paths,
-            input: variables
-          })) {
-            throw error;
-          }
-          return null;
-        }
-        return result.data;
-      }
-    };
-  };
-}
-
-// src/query-key-helpers.ts
-function createQueryKeyGetter(paths, method, prefix) {
-  return (input) => buildQueryKey(paths, input, method, prefix);
-}
-function createQueryFilter(paths, method, prefix) {
-  return (input) => ({
-    queryKey: buildQueryKey(paths, input, method, prefix),
-    exact: true
-  });
-}
-
-// src/proxy.ts
-var HTTP_METHODS = ["get", "post", "put", "patch", "delete", "head", "options"];
-function extendProxy(proxy, paths, config) {
-  const handler = {
-    get(target, prop) {
-      if (typeof prop === "symbol") return target[prop];
-      const value = target[prop];
-      if (typeof value === "function" && HTTP_METHODS.includes(prop)) {
-        const httpMethod = prop;
-        const callable = (...args) => value(...args);
-        return Object.assign(callable, {
-          ...httpMethod === "get" || httpMethod === "head" ? {
-            queryOptions: createQueryOptions(
-              callable,
-              paths,
-              httpMethod,
-              config
-            ),
-            queryKey: createQueryKeyGetter(paths, httpMethod, config.queryKeyPrefix),
-            queryFilter: createQueryFilter(paths, httpMethod, config.queryKeyPrefix)
-          } : {},
-          ...httpMethod === "post" || httpMethod === "put" || httpMethod === "patch" || httpMethod === "delete" ? {
-            mutationOptions: createMutationOptions(
-              callable,
-              paths,
-              httpMethod,
-              config
-            )
-          } : {}
-        });
-      }
-      if (value !== null && (typeof value === "object" || typeof value === "function")) {
-        return extendProxy(value, [...paths, prop], config);
-      }
-      return value;
-    },
-    apply(target, thisArg, args) {
-      const result = Reflect.apply(target, thisArg, args);
-      if (result !== null && (typeof result === "object" || typeof result === "function")) {
-        return extendProxy(result, paths, config);
-      }
-      return result;
-    }
-  };
-  return new Proxy(proxy, handler);
-}
-
-// src/index.ts
-import { treaty as treaty2 } from "@elysiajs/eden/treaty2";
-function createEdenQuery(domain, options) {
-  const treatyInstance = treaty(domain, options?.treaty);
-  return extendProxy(
-    treatyInstance,
-    [],
-    {
-      throwOnError: options?.throwOnError ?? true,
-      queryKeyPrefix: options?.queryKeyPrefix,
-      onError: options?.onError
-    }
-  );
-}
-export {
-  createEdenQuery,
-  treaty2 as treaty
-};
+"use strict";var c=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var w=Object.getOwnPropertyNames;var T=Object.prototype.hasOwnProperty;var q=(e,r)=>{for(var s in r)c(e,s,{get:r[s],enumerable:!0})},k=(e,r,s,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let a of w(r))!T.call(e,a)&&a!==s&&c(e,a,{get:()=>r[a],enumerable:!(n=m(r,a))||n.enumerable});return e};var Q=e=>k(c({},"__esModule",{value:!0}),e);var O={};q(O,{createEdenTQ:()=>P});module.exports=Q(O);var g=require("@elysiajs/eden/treaty2"),h=["get","post","put","delete","patch","options","head"];function b(e){return h.includes(e)}function d(e,r){let s=[];for(let n of e){let a=/^:(.+?)(\?)?$/.exec(n);if(!a){s.push(n);continue}let t=a[1],o=!!a[2],i=r?.[t];if(i==null){if(o)continue;throw new Error(`Missing required route parameter: "${t}"`)}s.push(String(i))}return s}function f(e,r,s,n){return[...e,r,s,n?.params??null,n?.query??null]}function p(e,r,s,n){let a=e;for(let o of r)a=a[o];let t={};return n?.query!==void 0&&(t.query=n.query),n?.headers!==void 0&&(t.headers=n.headers),n?.fetch!==void 0&&Object.assign(t,n.fetch),s==="get"||s==="head"?a[s](Object.keys(t).length>0?t:void 0):a[s](n?.body,Object.keys(t).length>0?t:void 0)}async function l(e){let r=await e;if(r.error)throw r.error;return r.data}function E(e,r,s){let n=[...r],a=t=>{let o=d(n,t?.params);return p(e.raw,o,s,t)};return a.queryKey=t=>f(e.prefix,s,n,t),a.queryOptions=(t,o)=>({queryKey:a.queryKey(t),queryFn:()=>{let i=d(n,t?.params);return l(p(e.raw,i,s,t))},...o}),a.mutationKey=t=>f(e.prefix,s,n,t),a.mutationOptions=t=>({mutationKey:[...e.prefix,s,n],mutationFn:o=>{let i=o,y=d(n,i?.params);return l(p(e.raw,y,s,i))},...t}),a.invalidate=async(t,o,i=!1)=>{let y=o?a.queryKey(o):[...e.prefix,s,n];await t.invalidateQueries({queryKey:y,exact:i})},a}function u(e,r=[]){return new Proxy(()=>{},{get(s,n){return b(n)?E(e,r,n):u(e,n==="index"?r:[...r,n])},apply(s,n,[a]){if(typeof a=="object"&&a!==null){let t=Object.values(a)[0];return u(e,[...r,t])}return u(e,r)}})}function P(e,r={}){let{queryKeyPrefix:s=["eden"],...n}=r,t={raw:(0,g.treaty)(e,n),prefix:s};return u(t)}0&&(module.exports={createEdenTQ});

package/dist/index.mjs

@@ -0,0 +1 @@
+import{treaty as l}from"@elysiajs/eden/treaty2";var g=["get","post","put","delete","patch","options","head"];function m(r){return g.includes(r)}function c(r,s){let t=[];for(let e of r){let a=/^:(.+?)(\?)?$/.exec(e);if(!a){t.push(e);continue}let n=a[1],o=!!a[2],i=s?.[n];if(i==null){if(o)continue;throw new Error(`Missing required route parameter: "${n}"`)}t.push(String(i))}return t}function p(r,s,t,e){return[...r,s,t,e?.params??null,e?.query??null]}function d(r,s,t,e){let a=r;for(let o of s)a=a[o];let n={};return e?.query!==void 0&&(n.query=e.query),e?.headers!==void 0&&(n.headers=e.headers),e?.fetch!==void 0&&Object.assign(n,e.fetch),t==="get"||t==="head"?a[t](Object.keys(n).length>0?n:void 0):a[t](e?.body,Object.keys(n).length>0?n:void 0)}async function f(r){let s=await r;if(s.error)throw s.error;return s.data}function w(r,s,t){let e=[...s],a=n=>{let o=c(e,n?.params);return d(r.raw,o,t,n)};return a.queryKey=n=>p(r.prefix,t,e,n),a.queryOptions=(n,o)=>({queryKey:a.queryKey(n),queryFn:()=>{let i=c(e,n?.params);return f(d(r.raw,i,t,n))},...o}),a.mutationKey=n=>p(r.prefix,t,e,n),a.mutationOptions=n=>({mutationKey:[...r.prefix,t,e],mutationFn:o=>{let i=o,y=c(e,i?.params);return f(d(r.raw,y,t,i))},...n}),a.invalidate=async(n,o,i=!1)=>{let y=o?a.queryKey(o):[...r.prefix,t,e];await n.invalidateQueries({queryKey:y,exact:i})},a}function u(r,s=[]){return new Proxy(()=>{},{get(t,e){return m(e)?w(r,s,e):u(r,e==="index"?s:[...s,e])},apply(t,e,[a]){if(typeof a=="object"&&a!==null){let n=Object.values(a)[0];return u(r,[...s,n])}return u(r,s)}})}function q(r,s={}){let{queryKeyPrefix:t=["eden"],...e}=s,n={raw:l(r,e),prefix:t};return u(n)}export{q as createEdenTQ};

package/package.json

@@ -1,42 +1,61 @@
 {
-  "name": "eden-tanstack-query",
-  "version": "0.0.9",
-  "description": "TanStack Query integration for Eden Treaty",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "test": "bun test",
-    "typecheck": "tsc --noEmit"
-  },
-  "peerDependencies": {
-    "@elysiajs/eden": ">=1.0.0",
-    "@tanstack/query-core": "^5.90.16"
-  },
-  "devDependencies": {
-    "@elysiajs/eden": "^1.4.6",
-    "@tanstack/react-query": "^5.90.16",
-    "@tanstack/svelte-query": "^6.0.14",
-    "bun-types": "latest",
-    "typescript": "^5.9.3"
-  },
-  "keywords": [
-    "elysia",
-    "eden",
-    "tanstack",
-    "query",
-    "react-query",
-    "svelte-query",
-    "typescript"
-  ]
+	"name": "eden-tanstack-query",
+	"version": "0.1.0-alpha.2",
+	"description": "TanStack Query integration for Elysia Eden - type-safe queries and mutations",
+	"author": {
+		"name": "Frank-III",
+		"url": "https://github.com/Frank-III"
+	},
+	"main": "./dist/index.js",
+	"module": "./dist/index.mjs",
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.mjs",
+			"require": "./dist/index.js"
+		}
+	},
+	"types": "./dist/index.d.ts",
+	"files": [
+		"dist",
+		"src"
+	],
+	"keywords": [
+		"elysia",
+		"eden",
+		"tanstack-query",
+		"react-query",
+		"svelte-query",
+		"vue-query",
+		"solid-query",
+		"type-safe",
+		"rpc"
+	],
+	"homepage": "https://github.com/Frank-III/eden",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Frank-III/eden"
+	},
+	"bugs": "https://github.com/Frank-III/eden/issues",
+	"license": "MIT",
+	"scripts": {
+		"build": "tsup",
+		"test": "bun test",
+		"prepublishOnly": "bun run build"
+	},
+	"peerDependencies": {
+		"@elysiajs/eden": ">=1.0.0",
+		"@tanstack/query-core": ">=5.0.0",
+		"elysia": ">=1.0.0"
+	},
+	"devDependencies": {
+		"@elysiajs/eden": "^1.4.6",
+		"@tanstack/query-core": "^5.90.20",
+		"@types/bun": "^1.3.8",
+		"elysia": "^1.4.22",
+		"expect-type": "^1.3.0",
+		"tsup": "^8.5.1",
+		"typescript": "^5.9.3"
+	}
 }