enlace 0.0.1-beta.4 → 0.0.1-beta.6

package/dist/index.js

@@ -21,408 +21,71 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  HTTP_METHODS: () => HTTP_METHODS,
-  clearCache: () => clearCache,
-  createEnlaceHook: () => createEnlaceHook,
-  invalidateTags: () => invalidateTags,
-  onRevalidate: () => onRevalidate
+  createEnlaceNext: () => createEnlaceNext
 });
 module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("enlace-core"), module.exports);
 
-// src/react/createEnlaceHook.ts
-var import_enlace_core = require("enlace-core");
-
-// src/react/useQueryMode.ts
-var import_react = require("react");
+// src/next/index.ts
+var import_enlace_core2 = require("enlace-core");
 
-// src/react/reducer.ts
-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;
-    case "FETCH_START":
-      return {
-        ...state,
-        loading: state.data === void 0,
-        fetching: true
-      };
-    case "FETCH_SUCCESS":
-      return {
-        loading: false,
-        fetching: false,
-        ok: true,
-        data: action.data,
-        error: void 0
-      };
-    case "FETCH_ERROR":
-      return {
-        loading: false,
-        fetching: false,
-        ok: false,
-        data: void 0,
-        error: action.error
-      };
-    case "SYNC_CACHE":
-      return action.state;
-    default:
-      return state;
-  }
-}
+// 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("/"));
 }
 
-// src/utils/sortObjectKeys.ts
-function sortObjectKeys(obj) {
-  if (obj === null || typeof obj !== "object") return obj;
-  if (Array.isArray(obj)) return obj.map(sortObjectKeys);
-  return Object.keys(obj).sort().reduce(
-    (sorted, key) => {
-      sorted[key] = sortObjectKeys(obj[key]);
-      return sorted;
-    },
-    {}
-  );
-}
-
-// src/react/cache.ts
-var cache = /* @__PURE__ */ new Map();
-function createQueryKey(tracked) {
-  return JSON.stringify(
-    sortObjectKeys({
-      path: tracked.path,
-      method: tracked.method,
-      options: tracked.options
-    })
-  );
-}
-function getCache(key) {
-  return cache.get(key);
-}
-function setCache(key, entry) {
-  const existing = cache.get(key);
-  if (existing) {
-    if ("ok" in entry) {
-      delete existing.promise;
-    }
-    Object.assign(existing, entry);
-    existing.subscribers.forEach((cb) => cb());
-  } else {
-    cache.set(key, {
-      data: void 0,
-      error: void 0,
-      ok: void 0,
-      timestamp: 0,
-      tags: [],
-      subscribers: /* @__PURE__ */ new Set(),
-      ...entry
-    });
-  }
-}
-function subscribeCache(key, callback) {
-  let entry = cache.get(key);
-  if (!entry) {
-    cache.set(key, {
-      data: void 0,
-      error: void 0,
-      ok: void 0,
-      timestamp: 0,
-      tags: [],
-      subscribers: /* @__PURE__ */ new Set()
-    });
-    entry = cache.get(key);
-  }
-  entry.subscribers.add(callback);
-  return () => {
-    entry.subscribers.delete(callback);
-  };
-}
-function isStale(key, staleTime) {
-  const entry = cache.get(key);
-  if (!entry) return true;
-  return Date.now() - entry.timestamp > staleTime;
-}
-function clearCache(key) {
-  if (key) {
-    cache.delete(key);
-  } else {
-    cache.clear();
-  }
-}
-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;
-    }
-  });
-}
-
-// src/react/revalidator.ts
-var listeners = /* @__PURE__ */ new Set();
-function invalidateTags(tags) {
-  clearCacheByTags(tags);
-  listeners.forEach((listener) => listener(tags));
-}
-function onRevalidate(callback) {
-  listeners.add(callback);
-  return () => listeners.delete(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}`);
+// src/next/fetch.ts
+async function executeNextFetch(baseUrl, path, method, combinedOptions, requestOptions) {
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    revalidator,
+    onSuccess,
+    ...coreOptions
+  } = combinedOptions;
+  const isGet = method === "GET";
+  const autoTags = generateTags(path);
+  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);
       }
-      return String(value);
     }
-    return segment;
-  });
-}
-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 queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(resolvedPath) : []);
-  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));
-    return {
-      loading: !hasCachedData && (isFetching || needsFetch),
-      fetching: isFetching || needsFetch,
-      ok: cached?.ok,
-      data: cached?.data,
-      error: cached?.error
-    };
+    onSuccess?.(payload);
   };
-  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 }
-      });
-      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) {
-        return;
-      }
-      dispatch({ type: "FETCH_START" });
-      let current = api;
-      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, {
-        promise: fetchPromise,
-        tags: queryTags
-      });
-    };
-    fetchRef.current = doFetch;
-    const cached = getCache(queryKey);
-    if (cached?.data !== void 0 && !isStale(queryKey, staleTime)) {
-      dispatch({ type: "SYNC_CACHE", state: getCacheState() });
-    } else {
-      doFetch();
+  const nextRequestOptions = { ...requestOptions };
+  if (isGet) {
+    const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
+    const nextFetchOptions = {};
+    if (tags) {
+      nextFetchOptions.tags = tags;
     }
-    return () => {
-      mountedRef.current = false;
-      fetchRef.current = null;
-      unsubscribe();
-    };
-  }, [queryKey, enabled]);
-  (0, import_react.useEffect)(() => {
-    if (queryTags.length === 0) return;
-    return onRevalidate((invalidatedTags) => {
-      const hasMatch = invalidatedTags.some((tag) => queryTags.includes(tag));
-      if (hasMatch && mountedRef.current && fetchRef.current) {
-        fetchRef.current();
-      }
-    });
-  }, [JSON.stringify(queryTags)]);
-  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({ ok: true, data: 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 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);
+    if (requestOptions?.revalidate !== void 0) {
+      nextFetchOptions.revalidate = requestOptions.revalidate;
     }
-    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 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 tagsToInvalidate = options?.revalidateTags ?? (autoRevalidateRef.current ? generateTags(resolvedPath) : []);
-        if (tagsToInvalidate.length > 0) {
-          invalidateTags(tagsToInvalidate);
-        }
-      } else {
-        dispatch({ type: "FETCH_ERROR", error: res.error });
-      }
-      return res;
-    });
+    nextRequestOptions.next = nextFetchOptions;
   }
-  return {
-    trigger: triggerRef.current,
-    ...state
-  };
+  return (0, import_enlace_core.executeFetch)(
+    baseUrl,
+    path,
+    method,
+    { ...coreOptions, onSuccess: nextOnSuccess },
+    nextRequestOptions
+  );
 }
 
-// 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
-  } = hookOptions;
-  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
-      });
-    }
-    return useQueryMode(
-      api,
-      trackingResult.trackedCall,
-      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
-    );
-  }
-  return useEnlaceHook;
+// src/next/index.ts
+function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+  const combinedOptions = { ...defaultOptions, ...nextOptions };
+  return (0, import_enlace_core2.createProxyHandler)(
+    baseUrl,
+    combinedOptions,
+    [],
+    executeNextFetch
+  );
 }