enlace 0.0.0-alpha.4 → 0.0.1-beta.2

package/dist/next/index.d.ts

@@ -1,121 +1,74 @@
-type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-type SchemaMethod = "$get" | "$post" | "$put" | "$patch" | "$delete";
-type EnlaceResponse<TData, TError> = {
-    ok: true;
-    status: number;
-    data: TData;
-    error?: never;
-} | {
-    ok: false;
-    status: number;
-    data?: never;
-    error: TError;
-};
-type EnlaceOptions = Omit<RequestInit, "method" | "body">;
-type FetchExecutor<TOptions = EnlaceOptions, TRequestOptions = RequestOptions<unknown>> = <TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: TOptions, requestOptions?: TRequestOptions) => Promise<EnlaceResponse<TData, TError>>;
-type RequestOptions<TBody = never> = {
-    body?: TBody;
-    query?: Record<string, string | number | boolean | undefined>;
-    headers?: HeadersInit;
-    cache?: RequestCache;
-};
-type MethodDefinition = {
-    data: unknown;
-    error: unknown;
-    body?: unknown;
-};
-/**
- * Helper to define an endpoint with proper typing.
- * Provides cleaner syntax than writing { data, error, body } manually.
- *
- * @example
- * type MyApi = {
- *   posts: {
- *     $get: Endpoint<Post[], ApiError>;
- *     $post: Endpoint<Post, ApiError, CreatePost>;  // with body
- *     _: {
- *       $get: Endpoint<Post, NotFoundError>;
- *     };
- *   };
- * };
- */
-type Endpoint<TData, TError, TBody = never> = [TBody] extends [never] ? {
-    data: TData;
-    error: TError;
-} : {
-    data: TData;
-    error: TError;
-    body: TBody;
-};
-type ExtractMethodDef<TSchema, TMethod extends SchemaMethod> = TSchema extends {
-    [K in TMethod]: infer M;
-} ? M extends MethodDefinition ? M : never : never;
-type ExtractData<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
-    data: infer D;
-} ? D : never;
-type ExtractError<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
-    error: infer E;
-} ? E : never;
-type ExtractBody<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
-    body: infer B;
-} ? B : never;
-type HasMethod<TSchema, TMethod extends SchemaMethod> = TSchema extends {
-    [K in TMethod]: MethodDefinition;
-} ? true : false;
-type MethodFn<TSchema, TMethod extends SchemaMethod, TRequestOptionsBase = object> = HasMethod<TSchema, TMethod> extends true ? ExtractBody<TSchema, TMethod> extends never ? (options?: RequestOptions<never> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : (options: RequestOptions<ExtractBody<TSchema, TMethod>> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : never;
-type IsSpecialKey<K> = K extends SchemaMethod | "_" ? true : false;
-type StaticPathKeys<TSchema> = {
-    [K in keyof TSchema as IsSpecialKey<K> extends true ? never : K extends string ? K : never]: TSchema[K];
-};
-type ExtractDynamicSchema<TSchema> = TSchema extends {
-    _: infer D;
-} ? D : never;
-type MethodOrPath<TSchema, TMethodName extends string, TSchemaMethod extends SchemaMethod, TRequestOptionsBase = object> = TMethodName extends keyof TSchema ? EnlaceClient<TSchema[TMethodName], TRequestOptionsBase> : MethodFn<TSchema, TSchemaMethod, TRequestOptionsBase>;
-type HttpMethods<TSchema, TRequestOptionsBase = object> = {
-    get: MethodOrPath<TSchema, "get", "$get", TRequestOptionsBase>;
-    post: MethodOrPath<TSchema, "post", "$post", TRequestOptionsBase>;
-    put: MethodOrPath<TSchema, "put", "$put", TRequestOptionsBase>;
-    patch: MethodOrPath<TSchema, "patch", "$patch", TRequestOptionsBase>;
-    delete: MethodOrPath<TSchema, "delete", "$delete", TRequestOptionsBase>;
-};
-type DynamicAccess<TSchema, TRequestOptionsBase = object> = ExtractDynamicSchema<TSchema> extends never ? object : {
-    [key: string]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
-    [key: number]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+import { EnlaceOptions, WildcardClient, EnlaceClient } from 'enlace-core';
+export * from 'enlace-core';
+export { EnlaceOptions } from 'enlace-core';
+
+/** Per-request options for React hooks */
+type ReactRequestOptionsBase = {
+    /**
+     * Cache tags for caching (GET requests only)
+     * This will auto generate tags from the URL path if not provided and autoGenerateTags is enabled.
+     * But can be manually specified to override auto-generation.
+     * */
+    tags?: string[];
+    /** Tags to invalidate after mutation (triggers refetch in matching queries) */
+    revalidateTags?: string[];
 };
-type MethodNameKeys = "get" | "post" | "put" | "patch" | "delete";
-type EnlaceClient<TSchema, TRequestOptionsBase = object> = HttpMethods<TSchema, TRequestOptionsBase> & DynamicAccess<TSchema, TRequestOptionsBase> & {
-    [K in keyof StaticPathKeys<TSchema> as K extends MethodNameKeys ? never : K]: EnlaceClient<TSchema[K], TRequestOptionsBase>;
+
+type EnlaceHookOptions = {
+    /**
+     * Auto-generate cache tags from URL path for GET requests.
+     * e.g., `/posts/1` generates tags `['posts', 'posts/1']`
+     * @default true
+     */
+    autoGenerateTags?: boolean;
+    /** Auto-revalidate generated tags after successful mutations. @default true */
+    autoRevalidateTags?: boolean;
+    /** Time in ms before cached data is considered stale. @default 0 (always stale) */
+    staleTime?: number;
 };
-type WildcardMethodFn<TRequestOptionsBase = object> = (options?: RequestOptions<unknown> & TRequestOptionsBase) => Promise<EnlaceResponse<unknown, unknown>>;
+
 /**
- * Wildcard client type - allows any path access when no schema is provided.
- * All methods are available at every level and return unknown types.
+ * Handler function called after successful mutations to trigger server-side revalidation.
+ * @param tags - Cache tags to revalidate
+ * @param paths - URL paths to revalidate
  */
-type WildcardClient<TRequestOptionsBase = object> = {
-    get: WildcardMethodFn<TRequestOptionsBase>;
-    post: WildcardMethodFn<TRequestOptionsBase>;
-    put: WildcardMethodFn<TRequestOptionsBase>;
-    patch: WildcardMethodFn<TRequestOptionsBase>;
-    delete: WildcardMethodFn<TRequestOptionsBase>;
-} & {
-    [key: string]: WildcardClient<TRequestOptionsBase>;
-    [key: number]: WildcardClient<TRequestOptionsBase>;
-};
-
-type NextFetchOptions = {
-    revalidate?: number | false;
-    tags?: string[];
-};
 type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
-type NextEnlaceOptions = EnlaceOptions & {
-    revalidate?: RevalidateHandler;
+/** Next.js-specific options (third argument for createEnlace) */
+type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & {
+    /**
+     * Handler called after successful mutations to trigger server-side revalidation.
+     * Receives auto-generated or manually specified tags and paths.
+     * @example
+     * ```ts
+     * createEnlace("http://localhost:3000/api/", {}, {
+     *   revalidator: (tags, paths) => revalidateServerAction(tags, paths)
+     * });
+     * ```
+     */
+    revalidator?: RevalidateHandler;
 };
-type NextRequestOptionsBase = {
-    next?: NextFetchOptions;
-    revalidateTags?: string[];
+/** Next.js hook options (third argument for createEnlaceHook) - extends React's EnlaceHookOptions */
+type NextHookOptions = EnlaceHookOptions & Pick<NextOptions, "revalidator">;
+/** Per-request options for Next.js fetch - extends React's base options */
+type NextRequestOptionsBase = ReactRequestOptionsBase & {
+    /** Time in seconds to revalidate, or false to disable */
+    revalidate?: number | false;
+    /**
+     * URL paths to revalidate after mutation
+     * This doesn't do anything on the client by itself - it's passed to the revalidator handler.
+     * You must implement the revalidation logic in the revalidator.
+     */
     revalidatePaths?: string[];
+    /**
+     * Skip server-side revalidation for this request.
+     * Useful when autoRevalidateTags is enabled but you want to opt-out for specific mutations.
+     * You can still pass empty [] to revalidateTags to skip triggering revalidation.
+     * But this flag can be used if you want to revalidate client-side and skip server-side entirely.
+     * Eg. you don't fetch any data on server component and you might want to skip the overhead of revalidation.
+     */
+    skipRevalidator?: boolean;
 };
 
-declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: NextEnlaceOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
+declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
 
-export { type Endpoint, type EnlaceClient, type EnlaceOptions, type EnlaceResponse, type FetchExecutor, type HttpMethod, type MethodDefinition, type NextEnlaceOptions, type NextFetchOptions, type NextRequestOptionsBase, type RequestOptions, type RevalidateHandler, type SchemaMethod, type WildcardClient, createEnlace };
+export { type NextHookOptions, type NextOptions, type NextRequestOptionsBase, type RevalidateHandler, createEnlace };

package/dist/next/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/next/index.ts
@@ -33,130 +24,54 @@ __export(next_exports, {
   createEnlace: () => createEnlace
 });
 module.exports = __toCommonJS(next_exports);
-
-// src/utils/buildUrl.ts
-var import_query_string = __toESM(require("query-string"));
-function buildUrl(baseUrl, path, query) {
-  const normalizedBase = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-  const url = new URL(path.join("/"), normalizedBase);
-  if (query) {
-    url.search = import_query_string.default.stringify(query, { skipNull: true, skipEmptyString: true });
-  }
-  return url.toString();
-}
-
-// src/utils/isJsonBody.ts
-function isJsonBody(body) {
-  if (body === null || body === void 0) return false;
-  if (body instanceof FormData) return false;
-  if (body instanceof Blob) return false;
-  if (body instanceof ArrayBuffer) return false;
-  if (body instanceof URLSearchParams) return false;
-  if (body instanceof ReadableStream) return false;
-  if (typeof body === "string") return false;
-  return typeof body === "object";
-}
-
-// src/utils/mergeHeaders.ts
-function mergeHeaders(defaultHeaders, requestHeaders) {
-  if (!defaultHeaders && !requestHeaders) return void 0;
-  if (!defaultHeaders) return requestHeaders;
-  if (!requestHeaders) return defaultHeaders;
-  return {
-    ...Object.fromEntries(new Headers(defaultHeaders)),
-    ...Object.fromEntries(new Headers(requestHeaders))
-  };
-}
-
-// src/core/fetch.ts
-async function executeFetch(baseUrl, path, method, defaultOptions, requestOptions) {
-  const url = buildUrl(baseUrl, path, requestOptions?.query);
-  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
-  const fetchOptions = {
-    ...defaultOptions,
-    method
-  };
-  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) {
-    return {
-      ok: true,
-      status: response.status,
-      data: isJson ? await response.json() : response
-    };
-  }
-  return {
-    ok: false,
-    status: response.status,
-    error: isJson ? await response.json() : response
-  };
-}
-
-// src/core/proxy.ts
-var HTTP_METHODS = {
-  get: "GET",
-  post: "POST",
-  put: "PUT",
-  patch: "PATCH",
-  delete: "DELETE"
-};
-function createProxyHandler(baseUrl, defaultOptions, path = [], fetchExecutor = executeFetch) {
-  const handler = {
-    get(_target, prop) {
-      if (typeof prop === "symbol") return void 0;
-      const method = HTTP_METHODS[prop];
-      if (method) {
-        return (options) => fetchExecutor(baseUrl, path, method, defaultOptions, options);
-      }
-      return createProxyHandler(baseUrl, defaultOptions, [...path, prop], fetchExecutor);
-    }
-  };
-  return new Proxy({}, handler);
-}
+var import_enlace_core2 = require("enlace-core");
 
 // src/next/fetch.ts
+var import_enlace_core = require("enlace-core");
+
+// src/utils/generateTags.ts
 function generateTags(path) {
   return path.map((_, i) => path.slice(0, i + 1).join("/"));
 }
-async function executeNextFetch(baseUrl, path, method, defaultOptions, requestOptions) {
-  const url = buildUrl(baseUrl, path, requestOptions?.query);
-  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
-  const nextOptions = requestOptions?.next;
-  const tags = nextOptions?.tags ?? generateTags(path);
+
+// src/next/fetch.ts
+async function executeNextFetch(baseUrl, path, method, combinedOptions, requestOptions) {
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    revalidator,
+    headers: defaultHeaders,
+    ...restOptions
+  } = 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 = {
-    ...defaultOptions,
+    ...restOptions,
     method
   };
   if (requestOptions?.cache) {
     fetchOptions.cache = requestOptions.cache;
   }
-  const nextFetchOptions = { tags };
-  if (nextOptions?.revalidate !== void 0) {
-    nextFetchOptions.revalidate = nextOptions.revalidate;
+  if (isGet) {
+    const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
+    const nextFetchOptions = {};
+    if (tags) {
+      nextFetchOptions.tags = tags;
+    }
+    if (requestOptions?.revalidate !== void 0) {
+      nextFetchOptions.revalidate = requestOptions.revalidate;
+    }
+    fetchOptions.next = nextFetchOptions;
   }
-  fetchOptions.next = nextFetchOptions;
   if (headers) {
     fetchOptions.headers = headers;
   }
   if (requestOptions?.body !== void 0) {
-    if (isJsonBody(requestOptions.body)) {
+    if ((0, import_enlace_core.isJsonBody)(requestOptions.body)) {
       fetchOptions.body = JSON.stringify(requestOptions.body);
-      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
+      headers = (0, import_enlace_core.mergeHeaders)(headers, { "Content-Type": "application/json" });
       if (headers) {
         fetchOptions.headers = headers;
       }
@@ -168,9 +83,12 @@ async function executeNextFetch(baseUrl, path, method, defaultOptions, requestOp
   const contentType = response.headers.get("content-type");
   const isJson = contentType?.includes("application/json");
   if (response.ok) {
-    const { revalidateTags = [], revalidatePaths = [] } = requestOptions ?? {};
-    if (revalidateTags.length || revalidatePaths.length) {
-      defaultOptions.revalidate?.(revalidateTags, revalidatePaths);
+    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,
@@ -186,6 +104,8 @@ async function executeNextFetch(baseUrl, path, method, defaultOptions, requestOp
 }
 
 // src/next/index.ts
-function createEnlace(baseUrl, defaultOptions = {}) {
-  return createProxyHandler(baseUrl, defaultOptions, [], executeNextFetch);
+__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);
 }

package/dist/next/index.mjs

@@ -1,119 +1,51 @@
-// src/utils/buildUrl.ts
-import qs from "query-string";
-function buildUrl(baseUrl, path, query) {
-  const normalizedBase = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-  const url = new URL(path.join("/"), normalizedBase);
-  if (query) {
-    url.search = qs.stringify(query, { skipNull: true, skipEmptyString: true });
-  }
-  return url.toString();
-}
-
-// src/utils/isJsonBody.ts
-function isJsonBody(body) {
-  if (body === null || body === void 0) return false;
-  if (body instanceof FormData) return false;
-  if (body instanceof Blob) return false;
-  if (body instanceof ArrayBuffer) return false;
-  if (body instanceof URLSearchParams) return false;
-  if (body instanceof ReadableStream) return false;
-  if (typeof body === "string") return false;
-  return typeof body === "object";
-}
-
-// src/utils/mergeHeaders.ts
-function mergeHeaders(defaultHeaders, requestHeaders) {
-  if (!defaultHeaders && !requestHeaders) return void 0;
-  if (!defaultHeaders) return requestHeaders;
-  if (!requestHeaders) return defaultHeaders;
-  return {
-    ...Object.fromEntries(new Headers(defaultHeaders)),
-    ...Object.fromEntries(new Headers(requestHeaders))
-  };
-}
-
-// src/core/fetch.ts
-async function executeFetch(baseUrl, path, method, defaultOptions, requestOptions) {
-  const url = buildUrl(baseUrl, path, requestOptions?.query);
-  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
-  const fetchOptions = {
-    ...defaultOptions,
-    method
-  };
-  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) {
-    return {
-      ok: true,
-      status: response.status,
-      data: isJson ? await response.json() : response
-    };
-  }
-  return {
-    ok: false,
-    status: response.status,
-    error: isJson ? await response.json() : response
-  };
-}
-
-// src/core/proxy.ts
-var HTTP_METHODS = {
-  get: "GET",
-  post: "POST",
-  put: "PUT",
-  patch: "PATCH",
-  delete: "DELETE"
-};
-function createProxyHandler(baseUrl, defaultOptions, path = [], fetchExecutor = executeFetch) {
-  const handler = {
-    get(_target, prop) {
-      if (typeof prop === "symbol") return void 0;
-      const method = HTTP_METHODS[prop];
-      if (method) {
-        return (options) => fetchExecutor(baseUrl, path, method, defaultOptions, options);
-      }
-      return createProxyHandler(baseUrl, defaultOptions, [...path, prop], fetchExecutor);
-    }
-  };
-  return new Proxy({}, handler);
-}
+// src/next/index.ts
+import {
+  createProxyHandler
+} from "enlace-core";
 
 // src/next/fetch.ts
+import {
+  buildUrl,
+  isJsonBody,
+  mergeHeaders
+} from "enlace-core";
+
+// src/utils/generateTags.ts
 function generateTags(path) {
   return path.map((_, i) => path.slice(0, i + 1).join("/"));
 }
-async function executeNextFetch(baseUrl, path, method, defaultOptions, requestOptions) {
+
+// src/next/fetch.ts
+async function executeNextFetch(baseUrl, path, method, combinedOptions, requestOptions) {
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    revalidator,
+    headers: defaultHeaders,
+    ...restOptions
+  } = combinedOptions;
   const url = buildUrl(baseUrl, path, requestOptions?.query);
-  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
-  const nextOptions = requestOptions?.next;
-  const tags = nextOptions?.tags ?? generateTags(path);
+  let headers = mergeHeaders(defaultHeaders, requestOptions?.headers);
+  const isGet = method === "GET";
+  const autoTags = generateTags(path);
   const fetchOptions = {
-    ...defaultOptions,
+    ...restOptions,
     method
   };
   if (requestOptions?.cache) {
     fetchOptions.cache = requestOptions.cache;
   }
-  const nextFetchOptions = { tags };
-  if (nextOptions?.revalidate !== void 0) {
-    nextFetchOptions.revalidate = nextOptions.revalidate;
+  if (isGet) {
+    const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
+    const nextFetchOptions = {};
+    if (tags) {
+      nextFetchOptions.tags = tags;
+    }
+    if (requestOptions?.revalidate !== void 0) {
+      nextFetchOptions.revalidate = requestOptions.revalidate;
+    }
+    fetchOptions.next = nextFetchOptions;
   }
-  fetchOptions.next = nextFetchOptions;
   if (headers) {
     fetchOptions.headers = headers;
   }
@@ -132,9 +64,12 @@ async function executeNextFetch(baseUrl, path, method, defaultOptions, requestOp
   const contentType = response.headers.get("content-type");
   const isJson = contentType?.includes("application/json");
   if (response.ok) {
-    const { revalidateTags = [], revalidatePaths = [] } = requestOptions ?? {};
-    if (revalidateTags.length || revalidatePaths.length) {
-      defaultOptions.revalidate?.(revalidateTags, revalidatePaths);
+    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,
@@ -150,8 +85,10 @@ async function executeNextFetch(baseUrl, path, method, defaultOptions, requestOp
 }
 
 // src/next/index.ts
-function createEnlace(baseUrl, defaultOptions = {}) {
-  return createProxyHandler(baseUrl, defaultOptions, [], executeNextFetch);
+export * from "enlace-core";
+function createEnlace(baseUrl, defaultOptions = {}, nextOptions = {}) {
+  const combinedOptions = { ...defaultOptions, ...nextOptions };
+  return createProxyHandler(baseUrl, combinedOptions, [], executeNextFetch);
 }
 export {
   createEnlace

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "enlace",
-  "version": "0.0.0-alpha.4",
+  "version": "0.0.1-beta.2",
+  "license": "MIT",
   "files": [
     "dist"
   ],
@@ -14,33 +15,23 @@
       "types": "./dist/next/index.d.ts",
       "import": "./dist/next/index.mjs",
       "require": "./dist/next/index.js"
+    },
+    "./next/hook": {
+      "types": "./dist/next/hook/index.d.ts",
+      "import": "./dist/next/hook/index.mjs",
+      "require": "./dist/next/hook/index.js"
     }
   },
-  "license": "MIT",
-  "scripts": {
-    "dev": "tsup --watch",
-    "build": "tsup",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --max-warnings 0",
-    "prepublishOnly": "npm run build && npm run typecheck && npm run lint"
+  "dependencies": {
+    "enlace-core": "0.0.1-beta.2"
   },
   "peerDependencies": {
     "react": "^19"
   },
-  "devDependencies": {
-    "@eslint/js": "^9.39.1",
-    "@types/react": "^19.1.0",
-    "eslint": "^9.39.1",
-    "eslint-plugin-react": "^7.37.5",
-    "globals": "^16.5.0",
-    "jiti": "^2.6.1",
-    "prettier": "^3.7.4",
-    "tsup": "^8.5.1",
-    "tsx": "^4.21.0",
-    "typescript": "5.9.2",
-    "typescript-eslint": "^8.48.1"
-  },
-  "dependencies": {
-    "query-string": "^9.3.1"
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --max-warnings 0"
   }
-}
+}