enlace 0.0.1-beta.3 → 0.0.1-beta.5

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;
-  }
-  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
-    };
+    nextRequestOptions.next = nextFetchOptions;
   }
-  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,
@@ -255,11 +231,29 @@ function onRevalidate(callback) {
 }
 
 // src/react/useQueryMode.ts
+function resolvePath(path, pathParams) {
+  if (!pathParams) return path;
+  return path.map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      const value = pathParams[paramName];
+      if (value === void 0) {
+        throw new Error(`Missing path parameter: ${paramName}`);
+      }
+      return String(value);
+    }
+    return segment;
+  });
+}
 function useQueryMode(api, trackedCall, options) {
-  const { autoGenerateTags, staleTime } = options;
+  const { autoGenerateTags, staleTime, enabled } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
-  const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(trackedCall.path) : []);
+  const resolvedPath = resolvePath(
+    trackedCall.path,
+    requestOptions?.pathParams
+  );
+  const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(resolvedPath) : []);
   const getCacheState = (includeNeedsFetch = false) => {
     const cached = getCache(queryKey);
     const hasCachedData = cached?.data !== void 0;
@@ -273,17 +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" });
+      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) {
@@ -291,7 +290,7 @@ function useQueryMode(api, trackedCall, options) {
       }
       dispatch({ type: "FETCH_START" });
       let current = api;
-      for (const segment of trackedCall.path) {
+      for (const segment of resolvedPath) {
         current = current[segment];
       }
       const method = current[trackedCall.method];
@@ -299,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
@@ -318,12 +317,17 @@ 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;
       unsubscribe();
     };
-  }, [queryKey]);
+  }, [queryKey, enabled]);
   useEffect(() => {
     if (queryTags.length === 0) return;
     return onRevalidate((invalidatedTags) => {
@@ -338,23 +342,56 @@ function useQueryMode(api, trackedCall, options) {
 
 // src/react/useSelectorMode.ts
 import { useRef as useRef2, useReducer as useReducer2 } from "react";
-function useSelectorMode(method, path, autoRevalidateTags) {
+function resolvePath2(path, pathParams) {
+  if (!pathParams) return path;
+  return path.map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      const value = pathParams[paramName];
+      if (value === void 0) {
+        throw new Error(`Missing path parameter: ${paramName}`);
+      }
+      return String(value);
+    }
+    return segment;
+  });
+}
+function hasPathParams(path) {
+  return path.some((segment) => segment.startsWith(":"));
+}
+function useSelectorMode(config) {
+  const { method, api, path, methodName, autoRevalidateTags } = config;
   const [state, dispatch] = useReducer2(hookReducer, initialState);
   const methodRef = useRef2(method);
+  const apiRef = useRef2(api);
   const triggerRef = useRef2(null);
   const pathRef = useRef2(path);
+  const methodNameRef = useRef2(methodName);
   const autoRevalidateRef = useRef2(autoRevalidateTags);
   methodRef.current = method;
+  apiRef.current = api;
   pathRef.current = path;
+  methodNameRef.current = methodName;
   autoRevalidateRef.current = autoRevalidateTags;
   if (!triggerRef.current) {
     triggerRef.current = (async (...args) => {
       dispatch({ type: "FETCH_START" });
-      const res = await methodRef.current(...args);
+      const options = args[0];
+      const resolvedPath = resolvePath2(pathRef.current, options?.pathParams);
+      let res;
+      if (hasPathParams(pathRef.current)) {
+        let current = apiRef.current;
+        for (const segment of resolvedPath) {
+          current = current[segment];
+        }
+        const resolvedMethod = current[methodNameRef.current];
+        res = await resolvedMethod(...args);
+      } else {
+        res = await methodRef.current(...args);
+      }
       if (res.ok) {
         dispatch({ type: "FETCH_SUCCESS", data: res.data });
-        const options = args[0];
-        const tagsToInvalidate = options?.revalidateTags ?? (autoRevalidateRef.current ? generateTags(pathRef.current) : []);
+        const tagsToInvalidate = options?.revalidateTags ?? (autoRevalidateRef.current ? generateTags(resolvedPath) : []);
         if (tagsToInvalidate.length > 0) {
           invalidateTags(tagsToInvalidate);
         }
@@ -415,26 +452,30 @@ function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
     autoRevalidateTags,
     ...nextOptions
   });
-  function useEnlaceHook(selectorOrQuery) {
+  function useEnlaceHook(selectorOrQuery, queryOptions) {
     let trackedCall = null;
     let selectorPath = null;
+    let selectorMethod = null;
     const trackingProxy = createTrackingProxy((result2) => {
       trackedCall = result2.trackedCall;
       selectorPath = result2.selectorPath;
+      selectorMethod = result2.selectorMethod;
     });
     const result = selectorOrQuery(trackingProxy);
     if (typeof result === "function") {
       const actualResult = selectorOrQuery(api);
-      return useSelectorMode(
-        actualResult,
-        selectorPath ?? [],
+      return useSelectorMode({
+        method: actualResult,
+        api,
+        path: selectorPath ?? [],
+        methodName: selectorMethod ?? "",
         autoRevalidateTags
-      );
+      });
     }
     return useQueryMode(
       api,
       trackedCall,
-      { autoGenerateTags, staleTime }
+      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
     );
   }
   return useEnlaceHook;

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 = {
@@ -12,8 +12,55 @@ type ReactRequestOptionsBase = {
     tags?: string[];
     /** Tags to invalidate after mutation (triggers refetch in matching queries) */
     revalidateTags?: string[];
+    /**
+     * Path parameters for dynamic URL segments.
+     * Used to replace :paramName placeholders in the URL path.
+     * @example
+     * // With path api.products[':id'].delete
+     * trigger({ pathParams: { id: '123' } }) // → DELETE /products/123
+     */
+    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.
@@ -25,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;
 };
 
 /**
@@ -34,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.
@@ -68,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 = {
@@ -12,8 +12,55 @@ type ReactRequestOptionsBase = {
     tags?: string[];
     /** Tags to invalidate after mutation (triggers refetch in matching queries) */
     revalidateTags?: string[];
+    /**
+     * Path parameters for dynamic URL segments.
+     * Used to replace :paramName placeholders in the URL path.
+     * @example
+     * // With path api.products[':id'].delete
+     * trigger({ pathParams: { id: '123' } }) // → DELETE /products/123
+     */
+    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.
@@ -25,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;
 };
 
 /**
@@ -34,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.
@@ -68,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
+  );
 }