enlace 0.0.1-beta.7 → 0.0.1-beta.9

package/README.md

@@ -14,18 +14,25 @@ npm install enlace
 import { createEnlaceHookReact } from "enlace/hook";
 import { Endpoint } from "enlace";
 
+// Define your API error type
+type ApiError = { message: string; code: number };
+
 type ApiSchema = {
   posts: {
-    $get: Endpoint<Post[], ApiError>;
-    $post: Endpoint<Post, ApiError, CreatePost>;
+    $get: Post[]; // Simple: just data type
+    $post: Endpoint<Post, CreatePost>; // Data + Body
+    $put: Endpoint<Post, UpdatePost, CustomError>; // Data + Body + Custom Error
     _: {
-      $get: Endpoint<Post, ApiError>;
-      $delete: Endpoint<void, ApiError>;
+      $get: Post; // Simple: just data type
+      $delete: void; // Simple: void response
     };
   };
 };
 
-const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com");
+// Pass global error type as second generic
+const useAPI = createEnlaceHookReact<ApiSchema, ApiError>(
+  "https://api.example.com"
+);
 ```
 
 ## Schema Conventions
@@ -51,40 +58,77 @@ const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com");
 ```typescript
 import { Endpoint } from "enlace";
 
+type ApiError = { message: string };
+
 type ApiSchema = {
   users: {
-    $get: Endpoint<User[], ApiError>;           // GET /users
-    $post: Endpoint<User, ApiError>;            // POST /users
-    _: {                                        // /users/:id
-      $get: Endpoint<User, ApiError>;           // GET /users/:id
-      $put: Endpoint<User, ApiError>;           // PUT /users/:id
-      $delete: Endpoint<void, ApiError>;        // DELETE /users/:id
+    $get: User[]; // GET /users (simple)
+    $post: Endpoint<User, CreateUser>; // POST /users with body
+    _: {
+      // /users/:id
+      $get: User; // GET /users/:id (simple)
+      $put: Endpoint<User, UpdateUser>; // PUT /users/:id with body
+      $delete: void; // DELETE /users/:id (void response)
       profile: {
-        $get: Endpoint<Profile, ApiError>;      // GET /users/:id/profile
+        $get: Profile; // GET /users/:id/profile (simple)
       };
     };
   };
 };
 
+// Pass global error type - applies to all endpoints
+const api = createEnlace<ApiSchema, ApiError>("https://api.example.com");
+
 // Usage
-api.users.get();              // GET /users
-api.users[123].get();         // GET /users/123
+api.users.get(); // GET /users
+api.users[123].get(); // GET /users/123
 api.users[123].profile.get(); // GET /users/123/profile
 ```
 
 ### Endpoint Type
 
+The `Endpoint` type helper lets you define response data, request body, and optionally override the error type:
+
 ```typescript
-type Endpoint<TData, TError, TBody = never> = {
-  data: TData;    // Response data type
-  error: TError;  // Error response type (required)
-  body: TBody;    // Request body type (optional)
+// Signature: Endpoint<TData, TBody?, TError?>
+type Endpoint<TData, TBody = never, TError = never>;
+```
+
+**Three ways to define endpoints:**
+
+```typescript
+type ApiSchema = {
+  posts: {
+    // 1. Direct type (simplest) - just the data type
+    //    Error comes from global default
+    $get: Post[];
+
+    // 2. Endpoint with body - Endpoint<Data, Body>
+    //    Error comes from global default
+    $post: Endpoint<Post, CreatePost>;
+
+    // 3. Endpoint with custom error - Endpoint<Data, Body, Error>
+    //    Overrides global error type for this endpoint
+    $put: Endpoint<Post, UpdatePost, ValidationError>;
+
+    // void response - use void directly
+    $delete: void;
+
+    // Custom error without body - use `never` for body
+    $patch: Endpoint<Post, never, NotFoundError>;
+  };
 };
+```
+
+**Global error type:**
+
+```typescript
+type ApiError = { message: string; code: number };
 
-// Examples
-type GetUsers = Endpoint<User[], ApiError>;                   // GET, no body
-type CreateUser = Endpoint<User, ApiError, CreateUserInput>;  // POST with body
-type DeleteUser = Endpoint<void, NotFoundError>;              // DELETE, no response data
+// Second generic sets default error type for all endpoints
+const api = createEnlace<ApiSchema, ApiError>("https://api.example.com");
+// const useAPI = createEnlaceHookReact<ApiSchema, ApiError>("...");
+// const useAPI = createEnlaceHookNext<ApiSchema, ApiError>("...");
 ```
 
 ## React Hooks
@@ -95,12 +139,12 @@ For GET requests that fetch data automatically:
 
 ```typescript
 function Posts({ page, limit }: { page: number; limit: number }) {
-  const { data, loading, error, ok } = useAPI((api) =>
+  const { data, loading, error } = useAPI((api) =>
     api.posts.get({ query: { page, limit, published: true } })
   );
 
   if (loading) return <div>Loading...</div>;
-  if (!ok) return <div>Error: {error.message}</div>;
+  if (error) return <div>Error: {error.message}</div>;
 
   return (
     <ul>
@@ -113,6 +157,7 @@ function Posts({ page, limit }: { page: number; limit: number }) {
 ```
 
 **Features:**
+
 - Auto-fetches on mount
 - Re-fetches when dependencies change (no deps array needed!)
 - Returns cached data while revalidating
@@ -139,10 +184,9 @@ function ProductForm({ id }: { id: string | "new" }) {
 ```typescript
 // Also useful when waiting for a dependency
 function UserPosts({ userId }: { userId: string | undefined }) {
-  const { data } = useAPI(
-    (api) => api.users[userId!].posts.get(),
-    { enabled: userId !== undefined }
-  );
+  const { data } = useAPI((api) => api.users[userId!].posts.get(), {
+    enabled: userId !== undefined,
+  });
 }
 ```
 
@@ -206,7 +250,7 @@ function CreatePost() {
 
   const handleSubmit = async (title: string) => {
     const result = await trigger({ body: { title } });
-    if (result.ok) {
+    if (!result.error) {
       console.log("Created:", result.data);
     }
   };
@@ -247,7 +291,9 @@ function PostList({ posts }: { posts: Post[] }) {
 **Multiple path parameters:**
 
 ```typescript
-const { trigger } = useAPI((api) => api.users[":userId"].posts[":postId"].delete);
+const { trigger } = useAPI(
+  (api) => api.users[":userId"].posts[":postId"].delete
+);
 
 trigger({ pathParams: { userId: "1", postId: "42" } });
 // → DELETE /users/1/posts/42
@@ -311,9 +357,13 @@ trigger({ body: { title: "New" } });
 Control how long cached data is considered fresh:
 
 ```typescript
-const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {}, {
-  staleTime: 5000, // 5 seconds
-});
+const useAPI = createEnlaceHookReact<ApiSchema>(
+  "https://api.example.com",
+  {},
+  {
+    staleTime: 5000, // 5 seconds
+  }
+);
 ```
 
 - `staleTime: 0` (default) — Always revalidate on mount
@@ -338,10 +388,14 @@ trigger({
 ### Disable Auto-Revalidation
 
 ```typescript
-const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {}, {
-  autoGenerateTags: false,     // Disable auto tag generation
-  autoRevalidateTags: false,   // Disable auto revalidation
-});
+const useAPI = createEnlaceHookReact<ApiSchema>(
+  "https://api.example.com",
+  {},
+  {
+    autoGenerateTags: false, // Disable auto tag generation
+    autoRevalidateTags: false, // Disable auto revalidation
+  }
+);
 ```
 
 ## Hook Options
@@ -355,9 +409,9 @@ const useAPI = createEnlaceHookReact<ApiSchema>(
   },
   {
     // Hook options
-    autoGenerateTags: true,    // Auto-generate cache tags from URL
-    autoRevalidateTags: true,  // Auto-revalidate after mutations
-    staleTime: 0,              // Cache freshness duration (ms)
+    autoGenerateTags: true, // Auto-generate cache tags from URL
+    autoRevalidateTags: true, // Auto-revalidate after mutations
+    staleTime: 0, // Cache freshness duration (ms)
   }
 );
 ```
@@ -438,11 +492,12 @@ type EnlaceCallbackPayload<T> = {
 
 // onError payload (HTTP error or network error)
 type EnlaceErrorCallbackPayload<T> =
-  | { status: number; error: T; headers: Headers }  // HTTP error
-  | { status: 0; error: Error; headers: null };     // Network error
+  | { status: number; error: T; headers: Headers } // HTTP error
+  | { status: 0; error: Error; headers: null }; // Network error
 ```
 
 **Use cases:**
+
 - Global error logging/reporting
 - Toast notifications for all API errors
 - Authentication refresh on 401 errors
@@ -459,13 +514,12 @@ const result = useAPI((api) => api.posts.get());
 // With options
 const result = useAPI(
   (api) => api.posts.get(),
-  { enabled: true }  // Skip fetching when false
+  { enabled: true } // Skip fetching when false
 );
 
 type UseEnlaceQueryResult<TData, TError> = {
-  loading: boolean;   // No cached data and fetching
-  fetching: boolean;  // Request in progress
-  ok: boolean | undefined;
+  loading: boolean; // No cached data and fetching
+  fetching: boolean; // Request in progress
   data: TData | undefined;
   error: TError | undefined;
 };
@@ -475,10 +529,9 @@ type UseEnlaceQueryResult<TData, TError> = {
 
 ```typescript
 type UseEnlaceSelectorResult<TMethod> = {
-  trigger: TMethod;   // Function to trigger the request
+  trigger: TMethod; // Function to trigger the request
   loading: boolean;
   fetching: boolean;
-  ok: boolean | undefined;
   data: TData | undefined;
   error: TError | undefined;
 };
@@ -488,12 +541,12 @@ type UseEnlaceSelectorResult<TMethod> = {
 
 ```typescript
 type RequestOptions = {
-  query?: Record<string, unknown>;        // Query parameters
-  body?: TBody;                           // Request body
-  headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);  // Request headers
-  tags?: string[];                        // Cache tags (GET only)
-  revalidateTags?: string[];              // Tags to invalidate after mutation
-  pathParams?: Record<string, string | number>;  // Dynamic path parameters
+  query?: Record<string, unknown>; // Query parameters
+  body?: TBody; // Request body
+  headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>); // Request headers
+  tags?: string[]; // Cache tags (GET only)
+  revalidateTags?: string[]; // Tags to invalidate after mutation
+  pathParams?: Record<string, string | number>; // Dynamic path parameters
 };
 ```
 
@@ -508,7 +561,9 @@ Use `createEnlaceNext` from `enlace` for server components:
 ```typescript
 import { createEnlaceNext } from "enlace";
 
-const api = createEnlaceNext<ApiSchema>("https://api.example.com", {}, {
+type ApiError = { message: string };
+
+const api = createEnlaceNext<ApiSchema, ApiError>("https://api.example.com", {}, {
   autoGenerateTags: true,
 });
 
@@ -530,7 +585,11 @@ Use `createEnlaceHookNext` from `enlace/hook` for client components:
 
 import { createEnlaceHookNext } from "enlace/hook";
 
-const useAPI = createEnlaceHookNext<ApiSchema>("https://api.example.com");
+type ApiError = { message: string };
+
+const useAPI = createEnlaceHookNext<ApiSchema, ApiError>(
+  "https://api.example.com"
+);
 ```
 
 ### Server-Side Revalidation
@@ -558,9 +617,15 @@ export async function revalidateAction(tags: string[], paths: string[]) {
 import { createEnlaceHookNext } from "enlace/hook";
 import { revalidateAction } from "./actions";
 
-const useAPI = createEnlaceHookNext<ApiSchema>("/api", {}, {
-  revalidator: revalidateAction,
-});
+type ApiError = { message: string };
+
+const useAPI = createEnlaceHookNext<ApiSchema, ApiError>(
+  "/api",
+  {},
+  {
+    revalidator: revalidateAction,
+  }
+);
 ```
 
 **In components:**
@@ -572,8 +637,8 @@ function CreatePost() {
   const handleCreate = () => {
     trigger({
       body: { title: "New Post" },
-      revalidateTags: ["posts"],      // Passed to revalidator
-      revalidatePaths: ["/posts"],    // Passed to revalidator
+      revalidateTags: ["posts"], // Passed to revalidator
+      revalidatePaths: ["/posts"], // Passed to revalidator
     });
   };
 }
@@ -583,11 +648,11 @@ function CreatePost() {
 
 ```typescript
 api.posts.get({
-  tags: ["posts"],           // Next.js cache tags
-  revalidate: 60,            // ISR revalidation (seconds)
+  tags: ["posts"], // Next.js cache tags
+  revalidate: 60, // ISR revalidation (seconds)
   revalidateTags: ["posts"], // Tags to invalidate after mutation
-  revalidatePaths: ["/"],    // Paths to revalidate after mutation
-  skipRevalidator: false,    // Skip server-side revalidation
+  revalidatePaths: ["/"], // Paths to revalidate after mutation
+  skipRevalidator: false, // Skip server-side revalidation
 });
 ```
 
@@ -597,32 +662,47 @@ Works with Next.js API routes:
 
 ```typescript
 // Client component calling /api/posts
-const useAPI = createEnlaceHookNext<ApiSchema>("/api");
+const useAPI = createEnlaceHookNext<ApiSchema, ApiError>("/api");
 ```
 
 ---
 
 ## API Reference
 
-### `createEnlaceHookReact<TSchema>(baseUrl, options?, hookOptions?)`
+### `createEnlaceHookReact<TSchema, TDefaultError>(baseUrl, options?, hookOptions?)`
 
 Creates a React hook for making API calls.
 
-### `createEnlaceHookNext<TSchema>(baseUrl, options?, hookOptions?)`
+### `createEnlaceHookNext<TSchema, TDefaultError>(baseUrl, options?, hookOptions?)`
 
 Creates a Next.js hook with server revalidation support.
 
-**Parameters:**
+### `createEnlace<TSchema, TDefaultError>(baseUrl, options?, callbacks?)`
+
+Creates a typed API client (non-hook, for direct calls or server components).
+
+### `createEnlaceNext<TSchema, TDefaultError>(baseUrl, options?, nextOptions?)`
+
+Creates a Next.js typed API client with caching support.
+
+**Generic Parameters:**
+
+- `TSchema` — API schema type defining endpoints
+- `TDefaultError` — Default error type for all endpoints (default: `unknown`)
+
+**Function Parameters:**
+
 - `baseUrl` — Base URL for requests
 - `options` — Default fetch options (headers, cache, etc.)
-- `hookOptions` — Hook configuration
+- `hookOptions` / `callbacks` / `nextOptions` — Additional configuration
 
 **Hook Options:**
+
 ```typescript
 type EnlaceHookOptions = {
-  autoGenerateTags?: boolean;    // default: true
-  autoRevalidateTags?: boolean;  // default: true
-  staleTime?: number;            // default: 0
+  autoGenerateTags?: boolean; // default: true
+  autoRevalidateTags?: boolean; // default: true
+  staleTime?: number; // default: 0
   onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
   onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };

package/dist/hook/index.d.mts

@@ -28,13 +28,12 @@ type UseEnlaceQueryOptions = {
      */
     enabled?: boolean;
 };
-type ApiClient<TSchema, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TOptions>;
-type QueryFn<TSchema, TData, TError, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
-type SelectorFn<TSchema, TMethod, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => TMethod;
+type ApiClient<TSchema, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TDefaultError, TOptions>;
+type QueryFn<TSchema, TData, TError, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TDefaultError, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
+type SelectorFn<TSchema, TMethod, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TDefaultError, TOptions>) => TMethod;
 type HookState = {
     loading: boolean;
     fetching: boolean;
-    ok: boolean | undefined;
     data: unknown;
     error: unknown;
 };
@@ -46,18 +45,12 @@ type TrackedCall = {
 declare const HTTP_METHODS: readonly ["get", "post", "put", "patch", "delete"];
 type ExtractData<T> = T extends (...args: any[]) => Promise<EnlaceResponse<infer D, unknown>> ? D : never;
 type ExtractError<T> = T extends (...args: any[]) => Promise<EnlaceResponse<unknown, infer E>> ? E : never;
-/** Discriminated union for hook response state - enables type narrowing on ok check */
+/** Discriminated union for hook response state - enables type narrowing via error check */
 type HookResponseState<TData, TError> = {
-    ok: undefined;
-    data: undefined;
-    error: undefined;
-} | {
-    ok: true;
     data: TData;
-    error: undefined;
+    error?: undefined;
 } | {
-    ok: false;
-    data: undefined;
+    data?: undefined;
     error: TError;
 };
 /** Result when hook is called with query function (auto-fetch mode) */
@@ -89,9 +82,9 @@ type EnlaceHookOptions = {
     onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
 /** Hook type returned by createEnlaceHookReact */
-type EnlaceHook<TSchema> = {
-    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+type EnlaceHook<TSchema, TDefaultError = unknown> = {
+    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod, TDefaultError>): UseEnlaceSelectorResult<TMethod>;
+    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
 };
 
 /**
@@ -108,7 +101,7 @@ type EnlaceHook<TSchema> = {
  * const { trigger, loading, data, error } = useAPI((api) => api.posts.delete);
  * onClick={() => trigger({ body: { id: 1 } })}
  */
-declare function createEnlaceHookReact<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema>;
+declare function createEnlaceHookReact<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema, TDefaultError>;
 
 /**
  * Handler function called after successful mutations to trigger server-side revalidation.
@@ -151,12 +144,12 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
      */
     skipRevalidator?: boolean;
 };
-type NextQueryFn<TSchema, TData, TError> = QueryFn<TSchema, TData, TError, NextRequestOptionsBase>;
-type NextSelectorFn<TSchema, TMethod> = SelectorFn<TSchema, TMethod, NextRequestOptionsBase>;
+type NextQueryFn<TSchema, TData, TError, TDefaultError = unknown> = QueryFn<TSchema, TData, TError, TDefaultError, NextRequestOptionsBase>;
+type NextSelectorFn<TSchema, TMethod, TDefaultError = unknown> = SelectorFn<TSchema, TMethod, TDefaultError, NextRequestOptionsBase>;
 /** Hook type returned by createEnlaceHookNext */
-type NextEnlaceHook<TSchema> = {
-    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: NextSelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+type NextEnlaceHook<TSchema, TDefaultError = unknown> = {
+    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: NextSelectorFn<TSchema, TMethod, TDefaultError>): UseEnlaceSelectorResult<TMethod>;
+    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
 };
 
 /**
@@ -175,6 +168,6 @@ type NextEnlaceHook<TSchema> = {
  * // Selector mode - trigger for mutations
  * const { trigger } = useAPI((api) => api.posts.delete);
  */
-declare function createEnlaceHookNext<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema>;
+declare function createEnlaceHookNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema, TDefaultError>;
 
 export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type NextEnlaceHook, type NextHookOptions, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, createEnlaceHookNext, createEnlaceHookReact };

package/dist/hook/index.d.ts

@@ -28,13 +28,12 @@ type UseEnlaceQueryOptions = {
      */
     enabled?: boolean;
 };
-type ApiClient<TSchema, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TOptions>;
-type QueryFn<TSchema, TData, TError, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
-type SelectorFn<TSchema, TMethod, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => TMethod;
+type ApiClient<TSchema, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TDefaultError, TOptions>;
+type QueryFn<TSchema, TData, TError, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TDefaultError, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
+type SelectorFn<TSchema, TMethod, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TDefaultError, TOptions>) => TMethod;
 type HookState = {
     loading: boolean;
     fetching: boolean;
-    ok: boolean | undefined;
     data: unknown;
     error: unknown;
 };
@@ -46,18 +45,12 @@ type TrackedCall = {
 declare const HTTP_METHODS: readonly ["get", "post", "put", "patch", "delete"];
 type ExtractData<T> = T extends (...args: any[]) => Promise<EnlaceResponse<infer D, unknown>> ? D : never;
 type ExtractError<T> = T extends (...args: any[]) => Promise<EnlaceResponse<unknown, infer E>> ? E : never;
-/** Discriminated union for hook response state - enables type narrowing on ok check */
+/** Discriminated union for hook response state - enables type narrowing via error check */
 type HookResponseState<TData, TError> = {
-    ok: undefined;
-    data: undefined;
-    error: undefined;
-} | {
-    ok: true;
     data: TData;
-    error: undefined;
+    error?: undefined;
 } | {
-    ok: false;
-    data: undefined;
+    data?: undefined;
     error: TError;
 };
 /** Result when hook is called with query function (auto-fetch mode) */
@@ -89,9 +82,9 @@ type EnlaceHookOptions = {
     onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
 /** Hook type returned by createEnlaceHookReact */
-type EnlaceHook<TSchema> = {
-    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+type EnlaceHook<TSchema, TDefaultError = unknown> = {
+    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod, TDefaultError>): UseEnlaceSelectorResult<TMethod>;
+    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
 };
 
 /**
@@ -108,7 +101,7 @@ type EnlaceHook<TSchema> = {
  * const { trigger, loading, data, error } = useAPI((api) => api.posts.delete);
  * onClick={() => trigger({ body: { id: 1 } })}
  */
-declare function createEnlaceHookReact<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema>;
+declare function createEnlaceHookReact<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema, TDefaultError>;
 
 /**
  * Handler function called after successful mutations to trigger server-side revalidation.
@@ -151,12 +144,12 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
      */
     skipRevalidator?: boolean;
 };
-type NextQueryFn<TSchema, TData, TError> = QueryFn<TSchema, TData, TError, NextRequestOptionsBase>;
-type NextSelectorFn<TSchema, TMethod> = SelectorFn<TSchema, TMethod, NextRequestOptionsBase>;
+type NextQueryFn<TSchema, TData, TError, TDefaultError = unknown> = QueryFn<TSchema, TData, TError, TDefaultError, NextRequestOptionsBase>;
+type NextSelectorFn<TSchema, TMethod, TDefaultError = unknown> = SelectorFn<TSchema, TMethod, TDefaultError, NextRequestOptionsBase>;
 /** Hook type returned by createEnlaceHookNext */
-type NextEnlaceHook<TSchema> = {
-    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: NextSelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+type NextEnlaceHook<TSchema, TDefaultError = unknown> = {
+    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: NextSelectorFn<TSchema, TMethod, TDefaultError>): UseEnlaceSelectorResult<TMethod>;
+    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
 };
 
 /**
@@ -175,6 +168,6 @@ type NextEnlaceHook<TSchema> = {
  * // Selector mode - trigger for mutations
  * const { trigger } = useAPI((api) => api.posts.delete);
  */
-declare function createEnlaceHookNext<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema>;
+declare function createEnlaceHookNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema, TDefaultError>;
 
 export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type NextEnlaceHook, type NextHookOptions, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, createEnlaceHookNext, createEnlaceHookReact };

package/dist/hook/index.js

@@ -38,7 +38,6 @@ var import_react = require("react");
 var initialState = {
   loading: false,
   fetching: false,
-  ok: void 0,
   data: void 0,
   error: void 0
 };
@@ -56,7 +55,6 @@ function hookReducer(state, action) {
       return {
         loading: false,
         fetching: false,
-        ok: true,
         data: action.data,
         error: void 0
       };
@@ -64,7 +62,6 @@ function hookReducer(state, action) {
       return {
         loading: false,
         fetching: false,
-        ok: false,
         data: void 0,
         error: action.error
       };
@@ -110,7 +107,7 @@ function getCache(key) {
 function setCache(key, entry) {
   const existing = cache.get(key);
   if (existing) {
-    if ("ok" in entry) {
+    if ("data" in entry || "error" in entry) {
       delete existing.promise;
     }
     Object.assign(existing, entry);
@@ -119,7 +116,6 @@ function setCache(key, entry) {
     cache.set(key, {
       data: void 0,
       error: void 0,
-      ok: void 0,
       timestamp: 0,
       tags: [],
       subscribers: /* @__PURE__ */ new Set(),
@@ -133,7 +129,6 @@ function subscribeCache(key, callback) {
     cache.set(key, {
       data: void 0,
       error: void 0,
-      ok: void 0,
       timestamp: 0,
       tags: [],
       subscribers: /* @__PURE__ */ new Set()
@@ -156,7 +151,6 @@ function clearCacheByTags(tags) {
     if (hasMatch) {
       entry.data = void 0;
       entry.error = void 0;
-      entry.ok = void 0;
       entry.timestamp = 0;
       delete entry.promise;
     }
@@ -206,7 +200,6 @@ function useQueryMode(api, trackedCall, options) {
     return {
       loading: !hasCachedData && (isFetching || needsFetch),
       fetching: isFetching || needsFetch,
-      ok: cached?.ok,
       data: cached?.data,
       error: cached?.error
     };
@@ -241,9 +234,8 @@ function useQueryMode(api, trackedCall, options) {
       const fetchPromise = method(trackedCall.options).then((res) => {
         if (mountedRef.current) {
           setCache(queryKey, {
-            data: res.ok ? res.data : void 0,
-            error: res.ok || res.status === 0 ? void 0 : res.error,
-            ok: res.ok,
+            data: res.error ? void 0 : res.data,
+            error: res.error,
             timestamp: Date.now(),
             tags: queryTags
           });
@@ -300,7 +292,7 @@ function createTrackingProxy(onTrack) {
               selectorPath: null,
               selectorMethod: null
             });
-            return Promise.resolve({ ok: true, data: void 0 });
+            return Promise.resolve({ status: 200, data: void 0, error: void 0 });
           };
           onTrack({
             trackedCall: null,
@@ -365,7 +357,7 @@ function useSelectorMode(config) {
       } else {
         res = await methodRef.current(...args);
       }
-      if (res.ok) {
+      if (!res.error) {
         dispatch({ type: "FETCH_SUCCESS", data: res.data });
         const tagsToInvalidate = options?.revalidateTags ?? (autoRevalidateRef.current ? generateTags(resolvedPath) : []);
         if (tagsToInvalidate.length > 0) {

package/dist/hook/index.mjs

@@ -11,7 +11,6 @@ import { useRef, useReducer, useEffect } from "react";
 var initialState = {
   loading: false,
   fetching: false,
-  ok: void 0,
   data: void 0,
   error: void 0
 };
@@ -29,7 +28,6 @@ function hookReducer(state, action) {
       return {
         loading: false,
         fetching: false,
-        ok: true,
         data: action.data,
         error: void 0
       };
@@ -37,7 +35,6 @@ function hookReducer(state, action) {
       return {
         loading: false,
         fetching: false,
-        ok: false,
         data: void 0,
         error: action.error
       };
@@ -83,7 +80,7 @@ function getCache(key) {
 function setCache(key, entry) {
   const existing = cache.get(key);
   if (existing) {
-    if ("ok" in entry) {
+    if ("data" in entry || "error" in entry) {
       delete existing.promise;
     }
     Object.assign(existing, entry);
@@ -92,7 +89,6 @@ function setCache(key, entry) {
     cache.set(key, {
       data: void 0,
       error: void 0,
-      ok: void 0,
       timestamp: 0,
       tags: [],
       subscribers: /* @__PURE__ */ new Set(),
@@ -106,7 +102,6 @@ function subscribeCache(key, callback) {
     cache.set(key, {
       data: void 0,
       error: void 0,
-      ok: void 0,
       timestamp: 0,
       tags: [],
       subscribers: /* @__PURE__ */ new Set()
@@ -129,7 +124,6 @@ function clearCacheByTags(tags) {
     if (hasMatch) {
       entry.data = void 0;
       entry.error = void 0;
-      entry.ok = void 0;
       entry.timestamp = 0;
       delete entry.promise;
     }
@@ -179,7 +173,6 @@ function useQueryMode(api, trackedCall, options) {
     return {
       loading: !hasCachedData && (isFetching || needsFetch),
       fetching: isFetching || needsFetch,
-      ok: cached?.ok,
       data: cached?.data,
       error: cached?.error
     };
@@ -214,9 +207,8 @@ function useQueryMode(api, trackedCall, options) {
       const fetchPromise = method(trackedCall.options).then((res) => {
         if (mountedRef.current) {
           setCache(queryKey, {
-            data: res.ok ? res.data : void 0,
-            error: res.ok || res.status === 0 ? void 0 : res.error,
-            ok: res.ok,
+            data: res.error ? void 0 : res.data,
+            error: res.error,
             timestamp: Date.now(),
             tags: queryTags
           });
@@ -273,7 +265,7 @@ function createTrackingProxy(onTrack) {
               selectorPath: null,
               selectorMethod: null
             });
-            return Promise.resolve({ ok: true, data: void 0 });
+            return Promise.resolve({ status: 200, data: void 0, error: void 0 });
           };
           onTrack({
             trackedCall: null,
@@ -338,7 +330,7 @@ function useSelectorMode(config) {
       } else {
         res = await methodRef.current(...args);
       }
-      if (res.ok) {
+      if (!res.error) {
         dispatch({ type: "FETCH_SUCCESS", data: res.data });
         const tagsToInvalidate = options?.revalidateTags ?? (autoRevalidateRef.current ? generateTags(resolvedPath) : []);
         if (tagsToInvalidate.length > 0) {

package/dist/index.d.mts

@@ -78,6 +78,6 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
     skipRevalidator?: boolean;
 };
 
-declare function createEnlaceNext<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
+declare function createEnlaceNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, TDefaultError, NextRequestOptionsBase>;
 
 export { type NextOptions, type NextRequestOptionsBase, createEnlaceNext };

package/dist/index.d.ts

@@ -78,6 +78,6 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
     skipRevalidator?: boolean;
 };
 
-declare function createEnlaceNext<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
+declare function createEnlaceNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, TDefaultError, NextRequestOptionsBase>;
 
 export { type NextOptions, type NextRequestOptionsBase, createEnlaceNext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enlace",
-  "version": "0.0.1-beta.7",
+  "version": "0.0.1-beta.9",
   "license": "MIT",
   "files": [
     "dist"
@@ -18,7 +18,7 @@
     }
   },
   "dependencies": {
-    "enlace-core": "0.0.1-beta.5"
+    "enlace-core": "0.0.1-beta.7"
   },
   "peerDependencies": {
     "react": "^19"