eden-tanstack-query 0.0.4 → 0.0.7

package/README.md

@@ -160,19 +160,37 @@ const eden = createEdenQuery<App>('http://localhost:8080', {
 })
 ```
 
-### Known Limitation: `onSuccess` Data Type
+### Type-Safe Data Narrowing
 
-When using `throwOnError: true`, errors are thrown before reaching `onSuccess`. However, TypeScript cannot narrow the data type at compile-time since `throwOnError` is a runtime configuration. This means the `data` parameter in `onSuccess` may still include error union types from your response schema.
+When `throwOnError` is `true` (the default), errors are thrown before reaching callbacks like `select` and `onSuccess`. The library automatically narrows the data type to exclude error shapes:
 
-**Workaround**: Use the `vars` parameter instead of `data` when you only need input values (e.g., for cache invalidation):
+```typescript
+// Default: throwOnError = true
+// Data type in select/onSuccess excludes { error: string } shapes
+const eden = createEdenQuery<App>('http://localhost:8080')
+
+useQuery(eden.users.get.queryOptions(undefined, {
+  select: (data) => data.users,  // TypeScript knows data doesn't have error shape
+  onSuccess: (data) => {
+    console.log(data.users)  // No need for type guards
+  }
+}))
+```
+
+When `throwOnError` is `false` or a function, the full union type is preserved:
 
 ```typescript
-useMutation(eden.users.post.mutationOptions({
-  onSuccess: (_, vars) => {
-    // Use vars instead of data for invalidation
-    queryClient.invalidateQueries({
-      queryKey: eden.users({ id: vars.userId }).get.queryKey()
-    })
+// Explicit: throwOnError = false
+// Data type includes all response shapes (success and error)
+const eden = createEdenQuery<App>('http://localhost:8080', {
+  throwOnError: false
+})
+
+useQuery(eden.users.get.queryOptions(undefined, {
+  select: (data) => {
+    // Need to handle both success and error shapes
+    if ('error' in data) return null
+    return data.users
   }
 }))
 ```

package/dist/index.d.ts

@@ -14,6 +14,8 @@ interface EdenThrowOnErrorContext {
     input: unknown;
 }
 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[];
@@ -22,11 +24,23 @@ interface EdenErrorContext {
     input: unknown;
     type: 'query' | 'mutation';
 }
-interface EdenQueryConfig {
-    throwOnError?: boolean | EdenThrowOnError;
+interface EdenQueryConfig<TThrowOnError extends ThrowOnErrorOption = true> {
+    throwOnError?: TThrowOnError;
     queryKeyPrefix?: string | string[];
     onError?: (context: EdenErrorContext) => void;
 }
+/**
+ * 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;
 }
@@ -43,27 +57,46 @@ type EdenData<T> = Extract<AwaitedReturn<T>, {
 }> extends {
     data: infer D;
 } ? D : never;
-type EdenQueryMethod<TMethod extends Extract<HTTPMethod, 'get' | 'head'>, TCall extends (...args: any[]) => Promise<any>> = TCall & {
+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<EdenData<TCall>, EdenFetchError | Error, EdenData<TCall>, EdenQueryKey<FirstArg<TCall>, TMethod>, EdenPartial<NonNullable<FirstArg<TCall>>>>) => EdenQueryOptions<EdenData<TCall>, EdenFetchError | Error, EdenData<TCall>, EdenQueryKey<FirstArg<TCall>, TMethod>, EdenPartial<NonNullable<FirstArg<TCall>>>> & {
+    queryOptions: (input?: FirstArg<TCall>, options?: EdenQueryOptions<NarrowedData<EdenData<TCall>, TThrowOnError>, EdenFetchError | Error, NarrowedData<EdenData<TCall>, TThrowOnError>, EdenQueryKey<FirstArg<TCall>, TMethod>, EdenPartial<NonNullable<FirstArg<TCall>>>>) => EdenQueryOptions<NarrowedData<EdenData<TCall>, TThrowOnError>, EdenFetchError | Error, NarrowedData<EdenData<TCall>, TThrowOnError>, EdenQueryKey<FirstArg<TCall>, TMethod>, EdenPartial<NonNullable<FirstArg<TCall>>>> & {
         queryKey: EdenQueryKey<FirstArg<TCall>, TMethod>;
-        queryFn: (context: QueryFunctionContext<EdenQueryKey<FirstArg<TCall>, TMethod>>) => Promise<EdenData<TCall>>;
+        queryFn: (context: QueryFunctionContext<EdenQueryKey<FirstArg<TCall>, TMethod>>) => Promise<NarrowedData<EdenData<TCall>, TThrowOnError>>;
     };
 };
-type EdenMutationMethod<TMethod extends Extract<HTTPMethod, 'post' | 'put' | 'patch' | 'delete'>, TCall extends (...args: any[]) => Promise<any>> = TCall & {
-    mutationOptions: (options?: EdenMutationOptions<EdenData<TCall>, EdenFetchError | Error, FirstArg<TCall>, unknown, EdenPartial<NonNullable<SecondArg<TCall>>>>) => EdenMutationOptions<EdenData<TCall>, EdenFetchError | Error, FirstArg<TCall>, unknown, EdenPartial<NonNullable<SecondArg<TCall>>>> & {
+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<EdenData<TCall>>;
+        mutationFn: (variables: FirstArg<TCall>) => Promise<NarrowedData<EdenData<TCall>, TThrowOnError>>;
     };
 };
-type EdenQueryify<T> = (T extends (...args: infer A) => infer R ? (...args: A) => EdenQueryify<R> : unknown) & (T extends object ? {
-    [K in keyof T]: EdenQueryifyValue<K, T[K]>;
+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> = K extends 'get' | 'head' ? V extends (...args: any[]) => Promise<any> ? EdenQueryMethod<Extract<K, 'get' | 'head'>, V> : V : K extends 'post' | 'put' | 'patch' | 'delete' ? V extends (...args: any[]) => Promise<any> ? EdenMutationMethod<Extract<K, 'post' | 'put' | 'patch' | 'delete'>, V> : V : EdenQueryify<V>;
+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>;
 
-declare function createEdenQuery<App extends Elysia<any, any, any, any, any, any, any>>(domain: string, options?: EdenQueryConfig & {
+/**
+ * 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>>;
+}): EdenQueryify<Treaty.Create<App>, TThrowOnError>;
 
-export { type EdenErrorContext, type EdenInfiniteQueryOptions, type EdenMutationMethod, type EdenMutationOptions, type EdenOptions, type EdenQueryConfig, type EdenQueryKey, type EdenQueryMethod, type EdenQueryOptions, type EdenQueryify, type EdenThrowOnError, type EdenThrowOnErrorContext, type HTTPMethod, createEdenQuery };
+export { type EdenErrorContext, type EdenInfiniteQueryOptions, type EdenMutationMethod, type EdenMutationOptions, type EdenOptions, type EdenQueryConfig, type EdenQueryKey, type EdenQueryMethod, type EdenQueryOptions, type EdenQueryify, type EdenThrowOnError, type EdenThrowOnErrorContext, type HTTPMethod, type NarrowedData, type ThrowOnErrorOption, createEdenQuery };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eden-tanstack-query",
-  "version": "0.0.4",
+  "version": "0.0.7",
   "description": "TanStack Query integration for Eden Treaty",
   "type": "module",
   "main": "./dist/index.js",