enlace 0.0.1-beta.4 → 0.0.1-beta.5

package/README.md

@@ -361,6 +361,92 @@ const useAPI = createEnlaceHook<ApiSchema>(
 );
 ```
 
+### Async Headers
+
+Headers can be provided as a static value, sync function, or async function. This is useful when you need to fetch headers dynamically (e.g., auth tokens from async storage):
+
+```typescript
+// Static headers
+const useAPI = createEnlaceHook<ApiSchema>("https://api.example.com", {
+  headers: { Authorization: "Bearer token" },
+});
+
+// Sync function
+const useAPI = createEnlaceHook<ApiSchema>("https://api.example.com", {
+  headers: () => ({ Authorization: `Bearer ${getToken()}` }),
+});
+
+// Async function
+const useAPI = createEnlaceHook<ApiSchema>("https://api.example.com", {
+  headers: async () => {
+    const token = await getTokenFromStorage();
+    return { Authorization: `Bearer ${token}` };
+  },
+});
+```
+
+This also works for per-request headers:
+
+```typescript
+const { data } = useAPI((api) =>
+  api.posts.get({
+    headers: async () => {
+      const token = await refreshToken();
+      return { Authorization: `Bearer ${token}` };
+    },
+  })
+);
+```
+
+### Global Callbacks
+
+You can set up global `onSuccess` and `onError` callbacks that are called for every request:
+
+```typescript
+const useAPI = createEnlaceHook<ApiSchema>(
+  "https://api.example.com",
+  {
+    headers: { Authorization: "Bearer token" },
+  },
+  {
+    onSuccess: (payload) => {
+      console.log("Request succeeded:", payload.status, payload.data);
+    },
+    onError: (payload) => {
+      if (payload.status === 0) {
+        // Network error
+        console.error("Network error:", payload.error.message);
+      } else {
+        // HTTP error (4xx, 5xx)
+        console.error("HTTP error:", payload.status, payload.error);
+      }
+    },
+  }
+);
+```
+
+**Callback Payloads:**
+
+```typescript
+// onSuccess payload
+type EnlaceCallbackPayload<T> = {
+  status: number;
+  data: T;
+  headers: Headers;
+};
+
+// 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
+```
+
+**Use cases:**
+- Global error logging/reporting
+- Toast notifications for all API errors
+- Authentication refresh on 401 errors
+- Analytics tracking
+
 ## Return Types
 
 ### Query Mode
@@ -403,6 +489,7 @@ type UseEnlaceSelectorResult<TMethod> = {
 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
@@ -531,6 +618,8 @@ type EnlaceHookOptions = {
   autoGenerateTags?: boolean;    // default: true
   autoRevalidateTags?: boolean;  // default: true
   staleTime?: number;            // default: 0
+  onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
+  onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
 ```
 

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { WildcardClient, EnlaceClient, EnlaceResponse, EnlaceOptions } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, EnlaceResponse, WildcardClient, EnlaceClient, EnlaceOptions } from 'enlace-core';
 export * from 'enlace-core';
 
 /** Per-request options for React hooks */
@@ -72,7 +72,7 @@ type UseEnlaceSelectorResult<TMethod> = {
     loading: boolean;
     fetching: boolean;
 } & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-
+/** Options for createEnlaceHook factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -84,11 +84,17 @@ type EnlaceHookOptions = {
     autoRevalidateTags?: boolean;
     /** Time in ms before cached data is considered stale. @default 0 (always stale) */
     staleTime?: number;
+    /** Callback called on successful API responses */
+    onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
+    /** Callback called on error responses (HTTP errors or network failures) */
+    onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
+/** Hook type returned by createEnlaceHook */
 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>;
 };
+
 /**
  * Creates a React hook for making API calls.
  * Called at module level to create a reusable hook.
@@ -111,4 +117,4 @@ declare function onRevalidate(callback: Listener): () => void;
 
 declare function clearCache(key?: string): void;
 
-export { type ApiClient, type EnlaceHookOptions, HTTP_METHODS, type HookState, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, clearCache, createEnlaceHook, invalidateTags, onRevalidate };
+export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, clearCache, createEnlaceHook, invalidateTags, onRevalidate };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { WildcardClient, EnlaceClient, EnlaceResponse, EnlaceOptions } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, EnlaceResponse, WildcardClient, EnlaceClient, EnlaceOptions } from 'enlace-core';
 export * from 'enlace-core';
 
 /** Per-request options for React hooks */
@@ -72,7 +72,7 @@ type UseEnlaceSelectorResult<TMethod> = {
     loading: boolean;
     fetching: boolean;
 } & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-
+/** Options for createEnlaceHook factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -84,11 +84,17 @@ type EnlaceHookOptions = {
     autoRevalidateTags?: boolean;
     /** Time in ms before cached data is considered stale. @default 0 (always stale) */
     staleTime?: number;
+    /** Callback called on successful API responses */
+    onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
+    /** Callback called on error responses (HTTP errors or network failures) */
+    onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
+/** Hook type returned by createEnlaceHook */
 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>;
 };
+
 /**
  * Creates a React hook for making API calls.
  * Called at module level to create a reusable hook.
@@ -111,4 +117,4 @@ declare function onRevalidate(callback: Listener): () => void;
 
 declare function clearCache(key?: string): void;
 
-export { type ApiClient, type EnlaceHookOptions, HTTP_METHODS, type HookState, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, clearCache, createEnlaceHook, invalidateTags, onRevalidate };
+export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, clearCache, createEnlaceHook, invalidateTags, onRevalidate };

package/dist/index.js

@@ -47,7 +47,7 @@ var initialState = {
 function hookReducer(state, action) {
   switch (action.type) {
     case "RESET":
-      return action.state;
+      return action.state ?? initialState;
     case "FETCH_START":
       return {
         ...state,
@@ -202,7 +202,10 @@ function useQueryMode(api, trackedCall, options) {
   const { autoGenerateTags, staleTime, enabled } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
-  const resolvedPath = resolvePath(trackedCall.path, requestOptions?.pathParams);
+  const resolvedPath = resolvePath(
+    trackedCall.path,
+    requestOptions?.pathParams
+  );
   const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(resolvedPath) : []);
   const getCacheState = (includeNeedsFetch = false) => {
     const cached = getCache(queryKey);
@@ -217,26 +220,22 @@ function useQueryMode(api, trackedCall, options) {
       error: cached?.error
     };
   };
-  const [state, dispatch] = (0, import_react.useReducer)(hookReducer, null, () => getCacheState(true));
+  const [state, dispatch] = (0, import_react.useReducer)(
+    hookReducer,
+    null,
+    () => getCacheState(true)
+  );
   const mountedRef = (0, import_react.useRef)(true);
   const fetchRef = (0, import_react.useRef)(null);
   (0, import_react.useEffect)(() => {
     mountedRef.current = true;
     if (!enabled) {
-      dispatch({
-        type: "RESET",
-        state: { loading: false, fetching: false, ok: void 0, data: void 0, error: void 0 }
-      });
+      dispatch({ type: "RESET" });
       return () => {
         mountedRef.current = false;
       };
     }
     dispatch({ type: "RESET", state: getCacheState(true) });
-    const unsubscribe = subscribeCache(queryKey, () => {
-      if (mountedRef.current) {
-        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
-      }
-    });
     const doFetch = () => {
       const cached2 = getCache(queryKey);
       if (cached2?.promise) {
@@ -252,7 +251,7 @@ function useQueryMode(api, trackedCall, options) {
         if (mountedRef.current) {
           setCache(queryKey, {
             data: res.ok ? res.data : void 0,
-            error: res.ok ? void 0 : res.error,
+            error: res.ok || res.status === 0 ? void 0 : res.error,
             ok: res.ok,
             timestamp: Date.now(),
             tags: queryTags
@@ -271,6 +270,11 @@ function useQueryMode(api, trackedCall, options) {
     } else {
       doFetch();
     }
+    const unsubscribe = subscribeCache(queryKey, () => {
+      if (mountedRef.current) {
+        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      }
+    });
     return () => {
       mountedRef.current = false;
       fetchRef.current = null;
@@ -390,12 +394,14 @@ function useSelectorMode(config) {
 
 // src/react/createEnlaceHook.ts
 function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
-  const api = (0, import_enlace_core.createEnlace)(baseUrl, defaultOptions);
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
-    staleTime = 0
+    staleTime = 0,
+    onSuccess,
+    onError
   } = hookOptions;
+  const api = (0, import_enlace_core.createEnlace)(baseUrl, defaultOptions, { onSuccess, onError });
   function useEnlaceHook(selectorOrQuery, queryOptions) {
     let trackingResult = {
       trackedCall: null,

package/dist/index.mjs

@@ -2,9 +2,7 @@
 export * from "enlace-core";
 
 // src/react/createEnlaceHook.ts
-import {
-  createEnlace
-} from "enlace-core";
+import { createEnlace } from "enlace-core";
 
 // src/react/useQueryMode.ts
 import { useRef, useReducer, useEffect } from "react";
@@ -20,7 +18,7 @@ var initialState = {
 function hookReducer(state, action) {
   switch (action.type) {
     case "RESET":
-      return action.state;
+      return action.state ?? initialState;
     case "FETCH_START":
       return {
         ...state,
@@ -175,7 +173,10 @@ function useQueryMode(api, trackedCall, options) {
   const { autoGenerateTags, staleTime, enabled } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
-  const resolvedPath = resolvePath(trackedCall.path, requestOptions?.pathParams);
+  const resolvedPath = resolvePath(
+    trackedCall.path,
+    requestOptions?.pathParams
+  );
   const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(resolvedPath) : []);
   const getCacheState = (includeNeedsFetch = false) => {
     const cached = getCache(queryKey);
@@ -190,26 +191,22 @@ function useQueryMode(api, trackedCall, options) {
       error: cached?.error
     };
   };
-  const [state, dispatch] = useReducer(hookReducer, null, () => getCacheState(true));
+  const [state, dispatch] = useReducer(
+    hookReducer,
+    null,
+    () => getCacheState(true)
+  );
   const mountedRef = useRef(true);
   const fetchRef = useRef(null);
   useEffect(() => {
     mountedRef.current = true;
     if (!enabled) {
-      dispatch({
-        type: "RESET",
-        state: { loading: false, fetching: false, ok: void 0, data: void 0, error: void 0 }
-      });
+      dispatch({ type: "RESET" });
       return () => {
         mountedRef.current = false;
       };
     }
     dispatch({ type: "RESET", state: getCacheState(true) });
-    const unsubscribe = subscribeCache(queryKey, () => {
-      if (mountedRef.current) {
-        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
-      }
-    });
     const doFetch = () => {
       const cached2 = getCache(queryKey);
       if (cached2?.promise) {
@@ -225,7 +222,7 @@ function useQueryMode(api, trackedCall, options) {
         if (mountedRef.current) {
           setCache(queryKey, {
             data: res.ok ? res.data : void 0,
-            error: res.ok ? void 0 : res.error,
+            error: res.ok || res.status === 0 ? void 0 : res.error,
             ok: res.ok,
             timestamp: Date.now(),
             tags: queryTags
@@ -244,6 +241,11 @@ function useQueryMode(api, trackedCall, options) {
     } else {
       doFetch();
     }
+    const unsubscribe = subscribeCache(queryKey, () => {
+      if (mountedRef.current) {
+        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      }
+    });
     return () => {
       mountedRef.current = false;
       fetchRef.current = null;
@@ -363,12 +365,14 @@ function useSelectorMode(config) {
 
 // src/react/createEnlaceHook.ts
 function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
-  const api = createEnlace(baseUrl, defaultOptions);
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
-    staleTime = 0
+    staleTime = 0,
+    onSuccess,
+    onError
   } = hookOptions;
+  const api = createEnlace(baseUrl, defaultOptions, { onSuccess, onError });
   function useEnlaceHook(selectorOrQuery, queryOptions) {
     let trackingResult = {
       trackedCall: null,

package/dist/next/hook/index.d.mts

@@ -1,4 +1,4 @@
-import { WildcardClient, EnlaceClient, EnlaceResponse, EnlaceOptions } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, WildcardClient, EnlaceClient, EnlaceResponse, EnlaceCallbacks, EnlaceOptions } from 'enlace-core';
 
 /** Per-request options for React hooks */
 type ReactRequestOptionsBase = {
@@ -58,7 +58,7 @@ type UseEnlaceSelectorResult<TMethod> = {
     loading: boolean;
     fetching: boolean;
 } & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-
+/** Options for createEnlaceHook factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -70,6 +70,10 @@ type EnlaceHookOptions = {
     autoRevalidateTags?: boolean;
     /** Time in ms before cached data is considered stale. @default 0 (always stale) */
     staleTime?: number;
+    /** Callback called on successful API responses */
+    onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
+    /** Callback called on error responses (HTTP errors or network failures) */
+    onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
 
 /**
@@ -79,7 +83,7 @@ type EnlaceHookOptions = {
  */
 type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
 /** Next.js-specific options (third argument for createEnlace) */
-type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & {
+type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
@@ -113,13 +117,14 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
      */
     skipRevalidator?: boolean;
 };
-
 type NextQueryFn<TSchema, TData, TError> = QueryFn<TSchema, TData, TError, NextRequestOptionsBase>;
 type NextSelectorFn<TSchema, TMethod> = SelectorFn<TSchema, TMethod, NextRequestOptionsBase>;
+/** Hook type returned by Next.js createEnlaceHook */
 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>;
 };
+
 /**
  * Creates a React hook for making API calls in Next.js Client Components.
  * Uses Next.js-specific features like revalidator for server-side cache invalidation.

package/dist/next/hook/index.d.ts

@@ -1,4 +1,4 @@
-import { WildcardClient, EnlaceClient, EnlaceResponse, EnlaceOptions } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, WildcardClient, EnlaceClient, EnlaceResponse, EnlaceCallbacks, EnlaceOptions } from 'enlace-core';
 
 /** Per-request options for React hooks */
 type ReactRequestOptionsBase = {
@@ -58,7 +58,7 @@ type UseEnlaceSelectorResult<TMethod> = {
     loading: boolean;
     fetching: boolean;
 } & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-
+/** Options for createEnlaceHook factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -70,6 +70,10 @@ type EnlaceHookOptions = {
     autoRevalidateTags?: boolean;
     /** Time in ms before cached data is considered stale. @default 0 (always stale) */
     staleTime?: number;
+    /** Callback called on successful API responses */
+    onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
+    /** Callback called on error responses (HTTP errors or network failures) */
+    onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
 
 /**
@@ -79,7 +83,7 @@ type EnlaceHookOptions = {
  */
 type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
 /** Next.js-specific options (third argument for createEnlace) */
-type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & {
+type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
@@ -113,13 +117,14 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
      */
     skipRevalidator?: boolean;
 };
-
 type NextQueryFn<TSchema, TData, TError> = QueryFn<TSchema, TData, TError, NextRequestOptionsBase>;
 type NextSelectorFn<TSchema, TMethod> = SelectorFn<TSchema, TMethod, NextRequestOptionsBase>;
+/** Hook type returned by Next.js createEnlaceHook */
 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>;
 };
+
 /**
  * Creates a React hook for making API calls in Next.js Client Components.
  * Uses Next.js-specific features like revalidator for server-side cache invalidation.

package/dist/next/hook/index.js

@@ -48,20 +48,22 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
     autoGenerateTags = true,
     autoRevalidateTags = true,
     revalidator,
-    headers: defaultHeaders,
-    ...restOptions
+    onSuccess,
+    ...coreOptions
   } = combinedOptions;
-  const url = (0, import_enlace_core.buildUrl)(baseUrl, path, requestOptions?.query);
-  let headers = (0, import_enlace_core.mergeHeaders)(defaultHeaders, requestOptions?.headers);
   const isGet = method === "GET";
   const autoTags = generateTags(path);
-  const fetchOptions = {
-    ...restOptions,
-    method
+  const nextOnSuccess = (payload) => {
+    if (!isGet && !requestOptions?.skipRevalidator) {
+      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
+      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
+      if (revalidateTags.length || revalidatePaths.length) {
+        revalidator?.(revalidateTags, revalidatePaths);
+      }
+    }
+    onSuccess?.(payload);
   };
-  if (requestOptions?.cache) {
-    fetchOptions.cache = requestOptions.cache;
-  }
+  const nextRequestOptions = { ...requestOptions };
   if (isGet) {
     const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
     const nextFetchOptions = {};
@@ -71,51 +73,27 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
     if (requestOptions?.revalidate !== void 0) {
       nextFetchOptions.revalidate = requestOptions.revalidate;
     }
-    fetchOptions.next = nextFetchOptions;
-  }
-  if (headers) {
-    fetchOptions.headers = headers;
+    nextRequestOptions.next = nextFetchOptions;
   }
-  if (requestOptions?.body !== void 0) {
-    if ((0, import_enlace_core.isJsonBody)(requestOptions.body)) {
-      fetchOptions.body = JSON.stringify(requestOptions.body);
-      headers = (0, import_enlace_core.mergeHeaders)(headers, { "Content-Type": "application/json" });
-      if (headers) {
-        fetchOptions.headers = headers;
-      }
-    } else {
-      fetchOptions.body = requestOptions.body;
-    }
-  }
-  const response = await fetch(url, fetchOptions);
-  const contentType = response.headers.get("content-type");
-  const isJson = contentType?.includes("application/json");
-  if (response.ok) {
-    if (!isGet && !requestOptions?.skipRevalidator) {
-      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
-      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
-      if (revalidateTags.length || revalidatePaths.length) {
-        revalidator?.(revalidateTags, revalidatePaths);
-      }
-    }
-    return {
-      ok: true,
-      status: response.status,
-      data: isJson ? await response.json() : response
-    };
-  }
-  return {
-    ok: false,
-    status: response.status,
-    error: isJson ? await response.json() : response
-  };
+  return (0, import_enlace_core.executeFetch)(
+    baseUrl,
+    path,
+    method,
+    { ...coreOptions, onSuccess: nextOnSuccess },
+    nextRequestOptions
+  );
 }
 
 // src/next/index.ts
 __reExport(next_exports, require("enlace-core"));
 function createEnlace(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
-  return (0, import_enlace_core2.createProxyHandler)(baseUrl, combinedOptions, [], executeNextFetch);
+  return (0, import_enlace_core2.createProxyHandler)(
+    baseUrl,
+    combinedOptions,
+    [],
+    executeNextFetch
+  );
 }
 
 // src/react/useQueryMode.ts
@@ -132,7 +110,7 @@ var initialState = {
 function hookReducer(state, action) {
   switch (action.type) {
     case "RESET":
-      return action.state;
+      return action.state ?? initialState;
     case "FETCH_START":
       return {
         ...state,
@@ -275,7 +253,10 @@ function useQueryMode(api, trackedCall, options) {
   const { autoGenerateTags, staleTime, enabled } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
-  const resolvedPath = resolvePath(trackedCall.path, requestOptions?.pathParams);
+  const resolvedPath = resolvePath(
+    trackedCall.path,
+    requestOptions?.pathParams
+  );
   const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(resolvedPath) : []);
   const getCacheState = (includeNeedsFetch = false) => {
     const cached = getCache(queryKey);
@@ -290,26 +271,22 @@ function useQueryMode(api, trackedCall, options) {
       error: cached?.error
     };
   };
-  const [state, dispatch] = (0, import_react.useReducer)(hookReducer, null, () => getCacheState(true));
+  const [state, dispatch] = (0, import_react.useReducer)(
+    hookReducer,
+    null,
+    () => getCacheState(true)
+  );
   const mountedRef = (0, import_react.useRef)(true);
   const fetchRef = (0, import_react.useRef)(null);
   (0, import_react.useEffect)(() => {
     mountedRef.current = true;
     if (!enabled) {
-      dispatch({
-        type: "RESET",
-        state: { loading: false, fetching: false, ok: void 0, data: void 0, error: void 0 }
-      });
+      dispatch({ type: "RESET" });
       return () => {
         mountedRef.current = false;
       };
     }
     dispatch({ type: "RESET", state: getCacheState(true) });
-    const unsubscribe = subscribeCache(queryKey, () => {
-      if (mountedRef.current) {
-        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
-      }
-    });
     const doFetch = () => {
       const cached2 = getCache(queryKey);
       if (cached2?.promise) {
@@ -325,7 +302,7 @@ function useQueryMode(api, trackedCall, options) {
         if (mountedRef.current) {
           setCache(queryKey, {
             data: res.ok ? res.data : void 0,
-            error: res.ok ? void 0 : res.error,
+            error: res.ok || res.status === 0 ? void 0 : res.error,
             ok: res.ok,
             timestamp: Date.now(),
             tags: queryTags
@@ -344,6 +321,11 @@ function useQueryMode(api, trackedCall, options) {
     } else {
       doFetch();
     }
+    const unsubscribe = subscribeCache(queryKey, () => {
+      if (mountedRef.current) {
+        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      }
+    });
     return () => {
       mountedRef.current = false;
       fetchRef.current = null;

package/dist/next/hook/index.mjs

@@ -29,9 +29,7 @@ import {
 
 // src/next/fetch.ts
 import {
-  buildUrl,
-  isJsonBody,
-  mergeHeaders
+  executeFetch
 } from "enlace-core";
 
 // src/utils/generateTags.ts
@@ -45,20 +43,22 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
     autoGenerateTags = true,
     autoRevalidateTags = true,
     revalidator,
-    headers: defaultHeaders,
-    ...restOptions
+    onSuccess,
+    ...coreOptions
   } = combinedOptions;
-  const url = buildUrl(baseUrl, path, requestOptions?.query);
-  let headers = mergeHeaders(defaultHeaders, requestOptions?.headers);
   const isGet = method === "GET";
   const autoTags = generateTags(path);
-  const fetchOptions = {
-    ...restOptions,
-    method
+  const nextOnSuccess = (payload) => {
+    if (!isGet && !requestOptions?.skipRevalidator) {
+      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
+      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
+      if (revalidateTags.length || revalidatePaths.length) {
+        revalidator?.(revalidateTags, revalidatePaths);
+      }
+    }
+    onSuccess?.(payload);
   };
-  if (requestOptions?.cache) {
-    fetchOptions.cache = requestOptions.cache;
-  }
+  const nextRequestOptions = { ...requestOptions };
   if (isGet) {
     const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
     const nextFetchOptions = {};
@@ -68,44 +68,15 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
     if (requestOptions?.revalidate !== void 0) {
       nextFetchOptions.revalidate = requestOptions.revalidate;
     }
-    fetchOptions.next = nextFetchOptions;
-  }
-  if (headers) {
-    fetchOptions.headers = headers;
+    nextRequestOptions.next = nextFetchOptions;
   }
-  if (requestOptions?.body !== void 0) {
-    if (isJsonBody(requestOptions.body)) {
-      fetchOptions.body = JSON.stringify(requestOptions.body);
-      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
-      if (headers) {
-        fetchOptions.headers = headers;
-      }
-    } else {
-      fetchOptions.body = requestOptions.body;
-    }
-  }
-  const response = await fetch(url, fetchOptions);
-  const contentType = response.headers.get("content-type");
-  const isJson = contentType?.includes("application/json");
-  if (response.ok) {
-    if (!isGet && !requestOptions?.skipRevalidator) {
-      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
-      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
-      if (revalidateTags.length || revalidatePaths.length) {
-        revalidator?.(revalidateTags, revalidatePaths);
-      }
-    }
-    return {
-      ok: true,
-      status: response.status,
-      data: isJson ? await response.json() : response
-    };
-  }
-  return {
-    ok: false,
-    status: response.status,
-    error: isJson ? await response.json() : response
-  };
+  return executeFetch(
+    baseUrl,
+    path,
+    method,
+    { ...coreOptions, onSuccess: nextOnSuccess },
+    nextRequestOptions
+  );
 }
 
 // src/next/index.ts
@@ -113,7 +84,12 @@ __reExport(next_exports, enlace_core_star);
 import * as enlace_core_star from "enlace-core";
 function createEnlace(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
-  return createProxyHandler(baseUrl, combinedOptions, [], executeNextFetch);
+  return createProxyHandler(
+    baseUrl,
+    combinedOptions,
+    [],
+    executeNextFetch
+  );
 }
 
 // src/react/useQueryMode.ts
@@ -130,7 +106,7 @@ var initialState = {
 function hookReducer(state, action) {
   switch (action.type) {
     case "RESET":
-      return action.state;
+      return action.state ?? initialState;
     case "FETCH_START":
       return {
         ...state,
@@ -273,7 +249,10 @@ function useQueryMode(api, trackedCall, options) {
   const { autoGenerateTags, staleTime, enabled } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
-  const resolvedPath = resolvePath(trackedCall.path, requestOptions?.pathParams);
+  const resolvedPath = resolvePath(
+    trackedCall.path,
+    requestOptions?.pathParams
+  );
   const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(resolvedPath) : []);
   const getCacheState = (includeNeedsFetch = false) => {
     const cached = getCache(queryKey);
@@ -288,26 +267,22 @@ function useQueryMode(api, trackedCall, options) {
       error: cached?.error
     };
   };
-  const [state, dispatch] = useReducer(hookReducer, null, () => getCacheState(true));
+  const [state, dispatch] = useReducer(
+    hookReducer,
+    null,
+    () => getCacheState(true)
+  );
   const mountedRef = useRef(true);
   const fetchRef = useRef(null);
   useEffect(() => {
     mountedRef.current = true;
     if (!enabled) {
-      dispatch({
-        type: "RESET",
-        state: { loading: false, fetching: false, ok: void 0, data: void 0, error: void 0 }
-      });
+      dispatch({ type: "RESET" });
       return () => {
         mountedRef.current = false;
       };
     }
     dispatch({ type: "RESET", state: getCacheState(true) });
-    const unsubscribe = subscribeCache(queryKey, () => {
-      if (mountedRef.current) {
-        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
-      }
-    });
     const doFetch = () => {
       const cached2 = getCache(queryKey);
       if (cached2?.promise) {
@@ -323,7 +298,7 @@ function useQueryMode(api, trackedCall, options) {
         if (mountedRef.current) {
           setCache(queryKey, {
             data: res.ok ? res.data : void 0,
-            error: res.ok ? void 0 : res.error,
+            error: res.ok || res.status === 0 ? void 0 : res.error,
             ok: res.ok,
             timestamp: Date.now(),
             tags: queryTags
@@ -342,6 +317,11 @@ function useQueryMode(api, trackedCall, options) {
     } else {
       doFetch();
     }
+    const unsubscribe = subscribeCache(queryKey, () => {
+      if (mountedRef.current) {
+        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      }
+    });
     return () => {
       mountedRef.current = false;
       fetchRef.current = null;

package/dist/next/index.d.mts

@@ -1,6 +1,6 @@
-import { EnlaceOptions, WildcardClient, EnlaceClient } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, WildcardClient, EnlaceClient, EnlaceResponse, EnlaceCallbacks, EnlaceOptions } from 'enlace-core';
 export * from 'enlace-core';
-export { EnlaceOptions } from 'enlace-core';
+export { EnlaceCallbacks, EnlaceOptions } from 'enlace-core';
 
 /** Per-request options for React hooks */
 type ReactRequestOptionsBase = {
@@ -21,7 +21,46 @@ type ReactRequestOptionsBase = {
      */
     pathParams?: Record<string, string | number>;
 };
-
+/** Options for query mode hooks */
+type UseEnlaceQueryOptions = {
+    /**
+     * Whether the query should execute.
+     * Set to false to skip fetching (useful when ID is "new" or undefined).
+     * @default true
+     */
+    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 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 */
+type HookResponseState<TData, TError> = {
+    ok: undefined;
+    data: undefined;
+    error: undefined;
+} | {
+    ok: true;
+    data: TData;
+    error: undefined;
+} | {
+    ok: false;
+    data: undefined;
+    error: TError;
+};
+/** Result when hook is called with query function (auto-fetch mode) */
+type UseEnlaceQueryResult<TData, TError> = {
+    loading: boolean;
+    fetching: boolean;
+} & HookResponseState<TData, TError>;
+/** Result when hook is called with method selector (trigger mode) */
+type UseEnlaceSelectorResult<TMethod> = {
+    trigger: TMethod;
+    loading: boolean;
+    fetching: boolean;
+} & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
+/** Options for createEnlaceHook factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -33,6 +72,10 @@ type EnlaceHookOptions = {
     autoRevalidateTags?: boolean;
     /** Time in ms before cached data is considered stale. @default 0 (always stale) */
     staleTime?: number;
+    /** Callback called on successful API responses */
+    onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
+    /** Callback called on error responses (HTTP errors or network failures) */
+    onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
 
 /**
@@ -42,7 +85,7 @@ type EnlaceHookOptions = {
  */
 type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
 /** Next.js-specific options (third argument for createEnlace) */
-type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & {
+type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
@@ -76,7 +119,15 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
      */
     skipRevalidator?: boolean;
 };
+type NextApiClient<TSchema> = ApiClient<TSchema, NextRequestOptionsBase>;
+type NextQueryFn<TSchema, TData, TError> = QueryFn<TSchema, TData, TError, NextRequestOptionsBase>;
+type NextSelectorFn<TSchema, TMethod> = SelectorFn<TSchema, TMethod, NextRequestOptionsBase>;
+/** Hook type returned by Next.js createEnlaceHook */
+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>;
+};
 
-declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
+declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
 
-export { type NextHookOptions, type NextOptions, type NextRequestOptionsBase, type RevalidateHandler, createEnlace };
+export { type NextApiClient, type NextEnlaceHook, type NextHookOptions, type NextOptions, type NextQueryFn, type NextRequestOptionsBase, type NextSelectorFn, type RevalidateHandler, createEnlace };

package/dist/next/index.d.ts

@@ -1,6 +1,6 @@
-import { EnlaceOptions, WildcardClient, EnlaceClient } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, WildcardClient, EnlaceClient, EnlaceResponse, EnlaceCallbacks, EnlaceOptions } from 'enlace-core';
 export * from 'enlace-core';
-export { EnlaceOptions } from 'enlace-core';
+export { EnlaceCallbacks, EnlaceOptions } from 'enlace-core';
 
 /** Per-request options for React hooks */
 type ReactRequestOptionsBase = {
@@ -21,7 +21,46 @@ type ReactRequestOptionsBase = {
      */
     pathParams?: Record<string, string | number>;
 };
-
+/** Options for query mode hooks */
+type UseEnlaceQueryOptions = {
+    /**
+     * Whether the query should execute.
+     * Set to false to skip fetching (useful when ID is "new" or undefined).
+     * @default true
+     */
+    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 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 */
+type HookResponseState<TData, TError> = {
+    ok: undefined;
+    data: undefined;
+    error: undefined;
+} | {
+    ok: true;
+    data: TData;
+    error: undefined;
+} | {
+    ok: false;
+    data: undefined;
+    error: TError;
+};
+/** Result when hook is called with query function (auto-fetch mode) */
+type UseEnlaceQueryResult<TData, TError> = {
+    loading: boolean;
+    fetching: boolean;
+} & HookResponseState<TData, TError>;
+/** Result when hook is called with method selector (trigger mode) */
+type UseEnlaceSelectorResult<TMethod> = {
+    trigger: TMethod;
+    loading: boolean;
+    fetching: boolean;
+} & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
+/** Options for createEnlaceHook factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -33,6 +72,10 @@ type EnlaceHookOptions = {
     autoRevalidateTags?: boolean;
     /** Time in ms before cached data is considered stale. @default 0 (always stale) */
     staleTime?: number;
+    /** Callback called on successful API responses */
+    onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
+    /** Callback called on error responses (HTTP errors or network failures) */
+    onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
 
 /**
@@ -42,7 +85,7 @@ type EnlaceHookOptions = {
  */
 type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
 /** Next.js-specific options (third argument for createEnlace) */
-type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & {
+type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
@@ -76,7 +119,15 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
      */
     skipRevalidator?: boolean;
 };
+type NextApiClient<TSchema> = ApiClient<TSchema, NextRequestOptionsBase>;
+type NextQueryFn<TSchema, TData, TError> = QueryFn<TSchema, TData, TError, NextRequestOptionsBase>;
+type NextSelectorFn<TSchema, TMethod> = SelectorFn<TSchema, TMethod, NextRequestOptionsBase>;
+/** Hook type returned by Next.js createEnlaceHook */
+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>;
+};
 
-declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
+declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
 
-export { type NextHookOptions, type NextOptions, type NextRequestOptionsBase, type RevalidateHandler, createEnlace };
+export { type NextApiClient, type NextEnlaceHook, type NextHookOptions, type NextOptions, type NextQueryFn, type NextRequestOptionsBase, type NextSelectorFn, type RevalidateHandler, createEnlace };

package/dist/next/index.js

@@ -40,20 +40,22 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
     autoGenerateTags = true,
     autoRevalidateTags = true,
     revalidator,
-    headers: defaultHeaders,
-    ...restOptions
+    onSuccess,
+    ...coreOptions
   } = combinedOptions;
-  const url = (0, import_enlace_core.buildUrl)(baseUrl, path, requestOptions?.query);
-  let headers = (0, import_enlace_core.mergeHeaders)(defaultHeaders, requestOptions?.headers);
   const isGet = method === "GET";
   const autoTags = generateTags(path);
-  const fetchOptions = {
-    ...restOptions,
-    method
+  const nextOnSuccess = (payload) => {
+    if (!isGet && !requestOptions?.skipRevalidator) {
+      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
+      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
+      if (revalidateTags.length || revalidatePaths.length) {
+        revalidator?.(revalidateTags, revalidatePaths);
+      }
+    }
+    onSuccess?.(payload);
   };
-  if (requestOptions?.cache) {
-    fetchOptions.cache = requestOptions.cache;
-  }
+  const nextRequestOptions = { ...requestOptions };
   if (isGet) {
     const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
     const nextFetchOptions = {};
@@ -63,49 +65,25 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
     if (requestOptions?.revalidate !== void 0) {
       nextFetchOptions.revalidate = requestOptions.revalidate;
     }
-    fetchOptions.next = nextFetchOptions;
-  }
-  if (headers) {
-    fetchOptions.headers = headers;
+    nextRequestOptions.next = nextFetchOptions;
   }
-  if (requestOptions?.body !== void 0) {
-    if ((0, import_enlace_core.isJsonBody)(requestOptions.body)) {
-      fetchOptions.body = JSON.stringify(requestOptions.body);
-      headers = (0, import_enlace_core.mergeHeaders)(headers, { "Content-Type": "application/json" });
-      if (headers) {
-        fetchOptions.headers = headers;
-      }
-    } else {
-      fetchOptions.body = requestOptions.body;
-    }
-  }
-  const response = await fetch(url, fetchOptions);
-  const contentType = response.headers.get("content-type");
-  const isJson = contentType?.includes("application/json");
-  if (response.ok) {
-    if (!isGet && !requestOptions?.skipRevalidator) {
-      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
-      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
-      if (revalidateTags.length || revalidatePaths.length) {
-        revalidator?.(revalidateTags, revalidatePaths);
-      }
-    }
-    return {
-      ok: true,
-      status: response.status,
-      data: isJson ? await response.json() : response
-    };
-  }
-  return {
-    ok: false,
-    status: response.status,
-    error: isJson ? await response.json() : response
-  };
+  return (0, import_enlace_core.executeFetch)(
+    baseUrl,
+    path,
+    method,
+    { ...coreOptions, onSuccess: nextOnSuccess },
+    nextRequestOptions
+  );
 }
 
 // src/next/index.ts
 __reExport(next_exports, require("enlace-core"), module.exports);
 function createEnlace(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
-  return (0, import_enlace_core2.createProxyHandler)(baseUrl, combinedOptions, [], executeNextFetch);
+  return (0, import_enlace_core2.createProxyHandler)(
+    baseUrl,
+    combinedOptions,
+    [],
+    executeNextFetch
+  );
 }

package/dist/next/index.mjs

@@ -5,9 +5,7 @@ import {
 
 // src/next/fetch.ts
 import {
-  buildUrl,
-  isJsonBody,
-  mergeHeaders
+  executeFetch
 } from "enlace-core";
 
 // src/utils/generateTags.ts
@@ -21,20 +19,22 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
     autoGenerateTags = true,
     autoRevalidateTags = true,
     revalidator,
-    headers: defaultHeaders,
-    ...restOptions
+    onSuccess,
+    ...coreOptions
   } = combinedOptions;
-  const url = buildUrl(baseUrl, path, requestOptions?.query);
-  let headers = mergeHeaders(defaultHeaders, requestOptions?.headers);
   const isGet = method === "GET";
   const autoTags = generateTags(path);
-  const fetchOptions = {
-    ...restOptions,
-    method
+  const nextOnSuccess = (payload) => {
+    if (!isGet && !requestOptions?.skipRevalidator) {
+      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
+      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
+      if (revalidateTags.length || revalidatePaths.length) {
+        revalidator?.(revalidateTags, revalidatePaths);
+      }
+    }
+    onSuccess?.(payload);
   };
-  if (requestOptions?.cache) {
-    fetchOptions.cache = requestOptions.cache;
-  }
+  const nextRequestOptions = { ...requestOptions };
   if (isGet) {
     const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
     const nextFetchOptions = {};
@@ -44,51 +44,27 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
     if (requestOptions?.revalidate !== void 0) {
       nextFetchOptions.revalidate = requestOptions.revalidate;
     }
-    fetchOptions.next = nextFetchOptions;
-  }
-  if (headers) {
-    fetchOptions.headers = headers;
+    nextRequestOptions.next = nextFetchOptions;
   }
-  if (requestOptions?.body !== void 0) {
-    if (isJsonBody(requestOptions.body)) {
-      fetchOptions.body = JSON.stringify(requestOptions.body);
-      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
-      if (headers) {
-        fetchOptions.headers = headers;
-      }
-    } else {
-      fetchOptions.body = requestOptions.body;
-    }
-  }
-  const response = await fetch(url, fetchOptions);
-  const contentType = response.headers.get("content-type");
-  const isJson = contentType?.includes("application/json");
-  if (response.ok) {
-    if (!isGet && !requestOptions?.skipRevalidator) {
-      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
-      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
-      if (revalidateTags.length || revalidatePaths.length) {
-        revalidator?.(revalidateTags, revalidatePaths);
-      }
-    }
-    return {
-      ok: true,
-      status: response.status,
-      data: isJson ? await response.json() : response
-    };
-  }
-  return {
-    ok: false,
-    status: response.status,
-    error: isJson ? await response.json() : response
-  };
+  return executeFetch(
+    baseUrl,
+    path,
+    method,
+    { ...coreOptions, onSuccess: nextOnSuccess },
+    nextRequestOptions
+  );
 }
 
 // src/next/index.ts
 export * from "enlace-core";
 function createEnlace(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
-  return createProxyHandler(baseUrl, combinedOptions, [], executeNextFetch);
+  return createProxyHandler(
+    baseUrl,
+    combinedOptions,
+    [],
+    executeNextFetch
+  );
 }
 export {
   createEnlace

package/package.json

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