enlace 0.0.1-beta.2 → 0.0.1-beta.20

package/dist/{next/hook → hook}/index.js

@@ -17,107 +17,20 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-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/createEnlaceHook.ts
-var createEnlaceHook_exports = {};
-__export(createEnlaceHook_exports, {
-  createEnlaceHook: () => createEnlaceHook
+// src/hook/index.ts
+var hook_exports = {};
+__export(hook_exports, {
+  HTTP_METHODS: () => HTTP_METHODS,
+  enlaceHookNext: () => enlaceHookNext,
+  enlaceHookReact: () => enlaceHookReact
 });
-module.exports = __toCommonJS(createEnlaceHook_exports);
+module.exports = __toCommonJS(hook_exports);
 
-// src/next/index.ts
-var next_exports = {};
-__export(next_exports, {
-  createEnlace: () => createEnlace
-});
-var import_enlace_core2 = require("enlace-core");
-
-// src/next/fetch.ts
+// src/react/enlaceHookReact.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("/"));
-}
-
-// 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 = {
-    ...restOptions,
-    method
-  };
-  if (requestOptions?.cache) {
-    fetchOptions.cache = requestOptions.cache;
-  }
-  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;
-  }
-  if (headers) {
-    fetchOptions.headers = headers;
-  }
-  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
-  };
-}
-
-// 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);
-}
-
 // src/react/useQueryMode.ts
 var import_react = require("react");
 
@@ -125,25 +38,31 @@ var import_react = require("react");
 var initialState = {
   loading: false,
   fetching: false,
-  ok: void 0,
   data: void 0,
   error: void 0
 };
 function hookReducer(state, action) {
   switch (action.type) {
     case "RESET":
-      return action.state;
+      return action.state ?? initialState;
     case "FETCH_START":
       return {
         ...state,
         loading: state.data === void 0,
-        fetching: true
+        fetching: true,
+        error: void 0
+      };
+    case "MUTATION_START":
+      return {
+        ...state,
+        loading: true,
+        fetching: true,
+        error: void 0
       };
     case "FETCH_SUCCESS":
       return {
         loading: false,
         fetching: false,
-        ok: true,
         data: action.data,
         error: void 0
       };
@@ -151,7 +70,6 @@ function hookReducer(state, action) {
       return {
         loading: false,
         fetching: false,
-        ok: false,
         data: void 0,
         error: action.error
       };
@@ -162,13 +80,27 @@ function hookReducer(state, action) {
   }
 }
 
+// src/utils/generateTags.ts
+function generateTags(path) {
+  return path.map((_, i) => path.slice(0, i + 1).join("/"));
+}
+
 // src/utils/sortObjectKeys.ts
-function sortObjectKeys(obj) {
+function sortObjectKeys(obj, seen = /* @__PURE__ */ new WeakSet()) {
   if (obj === null || typeof obj !== "object") return obj;
-  if (Array.isArray(obj)) return obj.map(sortObjectKeys);
+  if (seen.has(obj)) {
+    return "[Circular]";
+  }
+  seen.add(obj);
+  if (Array.isArray(obj)) {
+    return obj.map((item) => sortObjectKeys(item, seen));
+  }
   return Object.keys(obj).sort().reduce(
     (sorted, key) => {
-      sorted[key] = sortObjectKeys(obj[key]);
+      sorted[key] = sortObjectKeys(
+        obj[key],
+        seen
+      );
       return sorted;
     },
     {}
@@ -192,7 +124,7 @@ function getCache(key) {
 function setCache(key, entry) {
   const existing = cache.get(key);
   if (existing) {
-    if ("ok" in entry) {
+    if ("data" in entry || "error" in entry) {
       delete existing.promise;
     }
     Object.assign(existing, entry);
@@ -201,7 +133,6 @@ function setCache(key, entry) {
     cache.set(key, {
       data: void 0,
       error: void 0,
-      ok: void 0,
       timestamp: 0,
       tags: [],
       subscribers: /* @__PURE__ */ new Set(),
@@ -215,7 +146,6 @@ function subscribeCache(key, callback) {
     cache.set(key, {
       data: void 0,
       error: void 0,
-      ok: void 0,
       timestamp: 0,
       tags: [],
       subscribers: /* @__PURE__ */ new Set()
@@ -236,11 +166,9 @@ function clearCacheByTags(tags) {
   cache.forEach((entry) => {
     const hasMatch = entry.tags.some((tag) => tags.includes(tag));
     if (hasMatch) {
-      entry.data = void 0;
-      entry.error = void 0;
-      entry.ok = void 0;
       entry.timestamp = 0;
       delete entry.promise;
+      entry.subscribers.forEach((cb) => cb());
     }
   });
 }
@@ -257,35 +185,82 @@ function onRevalidate(callback) {
 }
 
 // src/react/useQueryMode.ts
+function resolvePath(path, params) {
+  if (!params) return path;
+  return path.map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      const value = params[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, pollingInterval } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
-  const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(trackedCall.path) : []);
+  const resolvedPath = resolvePath(trackedCall.path, requestOptions?.params);
+  const baseTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(resolvedPath) : []);
+  const queryTags = [...baseTags, ...requestOptions?.additionalTags ?? []];
   const getCacheState = (includeNeedsFetch = false) => {
     const cached = getCache(queryKey);
     const hasCachedData = cached?.data !== void 0;
     const isFetching = !!cached?.promise;
-    const needsFetch = includeNeedsFetch && (!hasCachedData || isStale(queryKey, staleTime));
+    const stale = isStale(queryKey, staleTime);
+    const needsFetch = includeNeedsFetch && (!hasCachedData || stale);
     return {
       loading: !hasCachedData && (isFetching || needsFetch),
       fetching: isFetching || needsFetch,
-      ok: cached?.ok,
       data: cached?.data,
       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);
+  const pollingTimeoutRef = (0, import_react.useRef)(null);
+  const pollingIntervalRef = (0, import_react.useRef)(pollingInterval);
+  pollingIntervalRef.current = pollingInterval;
   (0, import_react.useEffect)(() => {
     mountedRef.current = true;
+    if (!enabled) {
+      dispatch({ type: "RESET" });
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+        pollingTimeoutRef.current = null;
+      }
+      return () => {
+        mountedRef.current = false;
+      };
+    }
     dispatch({ type: "RESET", state: getCacheState(true) });
-    const unsubscribe = subscribeCache(queryKey, () => {
-      if (mountedRef.current) {
-        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+    const scheduleNextPoll = () => {
+      const currentPollingInterval = pollingIntervalRef.current;
+      if (!mountedRef.current || !enabled || currentPollingInterval === void 0) {
+        return;
       }
-    });
+      const cached2 = getCache(queryKey);
+      const interval = typeof currentPollingInterval === "function" ? currentPollingInterval(cached2?.data, cached2?.error) : currentPollingInterval;
+      if (interval === false || interval <= 0) {
+        return;
+      }
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+      }
+      pollingTimeoutRef.current = setTimeout(() => {
+        if (mountedRef.current && enabled && fetchRef.current) {
+          fetchRef.current();
+        }
+      }, interval);
+    };
     const doFetch = () => {
       const cached2 = getCache(queryKey);
       if (cached2?.promise) {
@@ -293,20 +268,26 @@ 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];
       const fetchPromise = method(trackedCall.options).then((res) => {
-        if (mountedRef.current) {
-          setCache(queryKey, {
-            data: res.ok ? res.data : void 0,
-            error: res.ok ? void 0 : res.error,
-            ok: res.ok,
-            timestamp: Date.now(),
-            tags: queryTags
-          });
-        }
+        setCache(queryKey, {
+          data: res.error ? void 0 : res.data,
+          error: res.error,
+          timestamp: Date.now(),
+          tags: queryTags
+        });
+      }).catch((err) => {
+        setCache(queryKey, {
+          data: void 0,
+          error: err,
+          timestamp: Date.now(),
+          tags: queryTags
+        });
+      }).finally(() => {
+        scheduleNextPoll();
       });
       setCache(queryKey, {
         promise: fetchPromise,
@@ -317,15 +298,25 @@ function useQueryMode(api, trackedCall, options) {
     const cached = getCache(queryKey);
     if (cached?.data !== void 0 && !isStale(queryKey, staleTime)) {
       dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      scheduleNextPoll();
     } else {
       doFetch();
     }
+    const unsubscribe = subscribeCache(queryKey, () => {
+      if (mountedRef.current) {
+        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      }
+    });
     return () => {
       mountedRef.current = false;
       fetchRef.current = null;
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+        pollingTimeoutRef.current = null;
+      }
       unsubscribe();
     };
-  }, [queryKey]);
+  }, [queryKey, enabled]);
   (0, import_react.useEffect)(() => {
     if (queryTags.length === 0) return;
     return onRevalidate((invalidatedTags) => {
@@ -338,25 +329,100 @@ function useQueryMode(api, trackedCall, options) {
   return state;
 }
 
+// src/react/types.ts
+var HTTP_METHODS = [
+  "$get",
+  "$post",
+  "$put",
+  "$patch",
+  "$delete"
+];
+
+// src/react/trackingProxy.ts
+function createTrackingProxy(onTrack) {
+  const createProxy = (path = []) => {
+    return new Proxy(() => {
+    }, {
+      get(_, prop) {
+        if (HTTP_METHODS.includes(prop)) {
+          const methodFn = (options) => {
+            onTrack({
+              trackedCall: { path, method: prop, options },
+              selectorPath: null,
+              selectorMethod: null
+            });
+            return Promise.resolve({
+              status: 200,
+              data: void 0,
+              error: void 0
+            });
+          };
+          onTrack({
+            trackedCall: null,
+            selectorPath: path,
+            selectorMethod: prop
+          });
+          return methodFn;
+        }
+        return createProxy([...path, prop]);
+      }
+    });
+  };
+  return createProxy();
+}
+
 // src/react/useSelectorMode.ts
 var import_react2 = require("react");
-function useSelectorMode(method, path, autoRevalidateTags) {
+function resolvePath2(path, params) {
+  if (!params) return path;
+  return path.map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      const value = params[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] = (0, import_react2.useReducer)(hookReducer, initialState);
   const methodRef = (0, import_react2.useRef)(method);
+  const apiRef = (0, import_react2.useRef)(api);
   const triggerRef = (0, import_react2.useRef)(null);
   const pathRef = (0, import_react2.useRef)(path);
+  const methodNameRef = (0, import_react2.useRef)(methodName);
   const autoRevalidateRef = (0, import_react2.useRef)(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);
-      if (res.ok) {
+      dispatch({ type: "MUTATION_START" });
+      const options = args[0];
+      const resolvedPath = resolvePath2(pathRef.current, options?.params);
+      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.error) {
         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);
         }
@@ -372,71 +438,170 @@ function useSelectorMode(method, path, autoRevalidateTags) {
   };
 }
 
-// src/react/types.ts
-var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+// src/react/enlaceHookReact.ts
+function enlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    staleTime = 0,
+    onSuccess,
+    onError
+  } = hookOptions;
+  const api = (0, import_enlace_core.enlace)(baseUrl, defaultOptions, {
+    onSuccess,
+    onError
+  });
+  function useEnlaceHook(selectorOrQuery, queryOptions) {
+    let trackingResult = {
+      trackedCall: null,
+      selectorPath: null,
+      selectorMethod: null
+    };
+    const trackingProxy = createTrackingProxy((result2) => {
+      trackingResult = result2;
+    });
+    const result = selectorOrQuery(trackingProxy);
+    if (typeof result === "function") {
+      const actualResult = selectorOrQuery(api);
+      return useSelectorMode({
+        method: actualResult,
+        api,
+        path: trackingResult.selectorPath ?? [],
+        methodName: trackingResult.selectorMethod ?? "",
+        autoRevalidateTags
+      });
+    }
+    if (!trackingResult.trackedCall) {
+      throw new Error(
+        "useAPI query mode requires calling an HTTP method ($get, $post, etc.). Did you mean to use selector mode? Example: useAPI((api) => api.posts.$get())"
+      );
+    }
+    return useQueryMode(
+      api,
+      trackingResult.trackedCall,
+      {
+        autoGenerateTags,
+        staleTime,
+        enabled: queryOptions?.enabled ?? true,
+        pollingInterval: queryOptions?.pollingInterval
+      }
+    );
+  }
+  return useEnlaceHook;
+}
 
-// src/react/trackingProxy.ts
-function createTrackingProxy(onTrack) {
-  const createProxy = (path = []) => {
-    return new Proxy(() => {
-    }, {
-      get(_, prop) {
-        if (HTTP_METHODS.includes(prop)) {
-          const methodFn = (options) => {
-            onTrack({
-              trackedCall: { path, method: prop, options },
-              selectorPath: null,
-              selectorMethod: null
-            });
-            return Promise.resolve({ ok: true, data: void 0 });
-          };
-          onTrack({
-            trackedCall: null,
-            selectorPath: path,
-            selectorMethod: prop
-          });
-          return methodFn;
+// src/next/index.ts
+var import_enlace_core3 = require("enlace-core");
+
+// src/next/fetch.ts
+var import_enlace_core2 = require("enlace-core");
+async function executeNextFetch(baseUrl, path, method, combinedOptions, requestOptions) {
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    skipServerRevalidation = false,
+    serverRevalidator,
+    onSuccess,
+    ...coreOptions
+  } = combinedOptions;
+  const isGet = method === "GET";
+  const autoTags = generateTags(path);
+  const nextOnSuccess = (payload) => {
+    if (!isGet) {
+      const shouldRevalidateServer = requestOptions?.serverRevalidate ?? !skipServerRevalidation;
+      if (shouldRevalidateServer) {
+        const baseRevalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
+        const revalidateTags = [
+          ...baseRevalidateTags,
+          ...requestOptions?.additionalRevalidateTags ?? []
+        ];
+        const revalidatePaths = requestOptions?.revalidatePaths ?? [];
+        if (revalidateTags.length || revalidatePaths.length) {
+          serverRevalidator?.(revalidateTags, revalidatePaths);
         }
-        return createProxy([...path, prop]);
       }
-    });
+    }
+    onSuccess?.(payload);
   };
-  return createProxy();
+  const nextRequestOptions = { ...requestOptions };
+  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;
+    }
+    nextRequestOptions.next = nextFetchOptions;
+  }
+  return (0, import_enlace_core2.executeFetch)(
+    baseUrl,
+    path,
+    method,
+    { ...coreOptions, onSuccess: nextOnSuccess },
+    nextRequestOptions
+  );
 }
 
-// src/next/createEnlaceHook.ts
-function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
+// src/next/index.ts
+function enlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+  const combinedOptions = { ...defaultOptions, ...nextOptions };
+  return (0, import_enlace_core3.createProxyHandler)(
+    baseUrl,
+    combinedOptions,
+    [],
+    executeNextFetch
+  );
+}
+
+// src/next/enlaceHookNext.ts
+function enlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
     staleTime = 0,
     ...nextOptions
   } = hookOptions;
-  const api = createEnlace(baseUrl, defaultOptions, {
+  const api = enlaceNext(baseUrl, defaultOptions, {
     autoGenerateTags,
     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
+      });
+    }
+    if (!trackedCall) {
+      throw new Error(
+        "useAPI query mode requires calling an HTTP method ($get, $post, etc.). Did you mean to use selector mode? Example: useAPI((api) => api.posts.$get())"
       );
     }
     return useQueryMode(
       api,
       trackedCall,
-      { autoGenerateTags, staleTime }
+      {
+        autoGenerateTags,
+        staleTime,
+        enabled: queryOptions?.enabled ?? true,
+        pollingInterval: queryOptions?.pollingInterval
+      }
     );
   }
   return useEnlaceHook;