@krymskyimaksym/react-api-client 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { createContext, useMemo, createElement, useContext, useCallback, useState, useEffect, useRef } from 'react';
+import { createContext, useCallback, useState, useEffect, useMemo, createElement, useContext, useRef } from 'react';
 
 // src/config.ts
 var globalConfig = null;
@@ -32,6 +32,52 @@ var ApiError = class _ApiError extends Error {
     Object.setPrototypeOf(this, _ApiError.prototype);
   }
 };
+var isObject = (v) => typeof v === "object" && v !== null;
+function toApiError(thrown) {
+  if (thrown instanceof ApiError) return thrown;
+  if (isObject(thrown) && "response" in thrown && isObject(thrown.response)) {
+    const r = thrown.response;
+    const status = typeof r.status === "number" ? r.status : 0;
+    const data = isObject(r.data) ? r.data : void 0;
+    const message = (data && typeof data.message === "string" ? data.message : void 0) ?? (thrown instanceof Error ? thrown.message : void 0) ?? `HTTP ${status}`;
+    return new ApiError({
+      message,
+      status,
+      code: data && typeof data.code === "string" ? data.code : void 0,
+      errors: data?.errors,
+      isNetworkError: status === 0,
+      isUnauthorized: status === 401,
+      isValidationError: status === 422 || data?.errors !== void 0,
+      raw: r.data ?? thrown
+    });
+  }
+  if (thrown instanceof Error) {
+    return new ApiError({
+      message: thrown.message,
+      status: 0,
+      isNetworkError: true,
+      raw: thrown
+    });
+  }
+  return new ApiError({
+    message: "Unknown error",
+    status: 0,
+    raw: thrown
+  });
+}
+function businessErrorToApiError(response) {
+  if (!isObject(response)) {
+    return new ApiError({ message: "Request failed", status: 200, raw: response });
+  }
+  return new ApiError({
+    message: typeof response.message === "string" ? response.message : "Request failed",
+    status: 200,
+    code: typeof response.code === "string" ? response.code : void 0,
+    errors: response.errors,
+    isValidationError: response.errors !== void 0,
+    raw: response
+  });
+}
 
 // src/utils.ts
 function buildEndpoint(endpoint, params) {
@@ -40,7 +86,7 @@ function buildEndpoint(endpoint, params) {
   }
   return endpoint;
 }
-async function executeRequest(endpoint, fetchConfig, params) {
+async function executeRequest(endpoint, fetchConfig, params, signal) {
   const url = buildEndpoint(endpoint, params);
   const config = getConfig();
   try {
@@ -51,7 +97,8 @@ async function executeRequest(endpoint, fetchConfig, params) {
         params: {
           ...requestConfig.requestParams,
           ...params
-        }
+        },
+        signal
       });
     } else {
       response = await config.httpClient.request(url, {
@@ -59,38 +106,29 @@ async function executeRequest(endpoint, fetchConfig, params) {
         data: {
           ...requestConfig.requestParams,
           ...params
-        }
+        },
+        signal
       });
     }
     const hasExplicitStatus = response && typeof response === "object" && "status" in response && typeof response.status === "boolean";
     if (config.throwOnError && hasExplicitStatus && response.status === false) {
-      const body = response;
-      throw new ApiError({
-        message: body.message ?? "Request failed",
-        status: 200,
-        errors: body.errors,
-        raw: response
-      });
+      throw businessErrorToApiError(response);
     }
     return { ...response, status: true };
   } catch (e) {
-    if (e instanceof ApiError) throw e;
+    if (e instanceof ApiError) {
+      if (e.status === 401 && config.onUnauthorized) {
+        await config.onUnauthorized();
+      }
+      throw e;
+    }
     const error = e;
     const httpStatus = error.response?.status;
     if (httpStatus === 401 && config.onUnauthorized) {
       await config.onUnauthorized();
     }
     if (config.throwOnError) {
-      const data = error.response?.data;
-      const isNetwork = httpStatus === void 0;
-      throw new ApiError({
-        message: data?.message ?? (e instanceof Error ? e.message : void 0) ?? (isNetwork ? "Network error" : "Request error"),
-        status: httpStatus ?? 0,
-        code: data?.code,
-        errors: data,
-        isNetworkError: isNetwork,
-        raw: e
-      });
+      throw toApiError(e);
     }
     if (error.response?.data) {
       return {
@@ -113,6 +151,21 @@ function handleResponse(result, onSuccess, onError) {
   }
 }
 
+// src/logger.ts
+function getLogger() {
+  if (!isConfigured()) return void 0;
+  return getConfig().logger;
+}
+function callLogger(method, ...args) {
+  const logger = getLogger();
+  const fn = logger?.[method];
+  if (!fn) return;
+  try {
+    fn(...args);
+  } catch {
+  }
+}
+
 // src/query/focus-manager.ts
 var FocusManager = class {
   constructor() {
@@ -251,6 +304,21 @@ var DEFAULT_STALE_TIME = 0;
 var QueryCache = class {
   constructor() {
     this.entries = /* @__PURE__ */ new Map();
+    this.globalListeners = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Подписка на любое изменение кэша: setData, invalidate, remove,
+   * успешный/ошибочный fetch. Используется persistQueryClient и
+   * devtools-подобными адаптерами. Не дублирует `subscribe(key, ...)`.
+   */
+  subscribeAll(listener) {
+    this.globalListeners.add(listener);
+    return () => {
+      this.globalListeners.delete(listener);
+    };
+  }
+  notifyGlobal() {
+    for (const listener of this.globalListeners) listener();
   }
   ensureEntry(key, staleTime, gcTime) {
     const hash = hashQueryKey(key);
@@ -267,7 +335,9 @@ var QueryCache = class {
         },
         subscribers: /* @__PURE__ */ new Set(),
         inflight: null,
+        inflightController: null,
         gcTimer: null,
+        lastQueryFn: null,
         staleTime: staleTime ?? DEFAULT_STALE_TIME,
         gcTime: gcTime ?? DEFAULT_GC_TIME
       };
@@ -315,6 +385,7 @@ var QueryCache = class {
   }
   notify(entry) {
     for (const listener of entry.subscribers) listener();
+    this.notifyGlobal();
   }
   scheduleGc(entry) {
     if (entry.gcTimer) clearTimeout(entry.gcTimer);
@@ -337,18 +408,21 @@ var QueryCache = class {
     const gcTime = options.gcTime ?? DEFAULT_GC_TIME;
     const entry = this.ensureEntry(key, staleTime, gcTime);
     const isFresh = entry.state.status === "success" && !entry.state.isStale && Date.now() - entry.state.updatedAt < staleTime;
+    entry.lastQueryFn = queryFn;
     if (!options.force && isFresh && entry.state.data !== void 0) {
       return entry.state.data;
     }
     if (entry.inflight) return entry.inflight;
     entry.state = { ...entry.state, status: "loading", error: null };
     this.notify(entry);
+    const controller = new AbortController();
     const token = Symbol("inflight");
     entry.inflightToken = token;
+    entry.inflightController = controller;
     const isCurrent = () => entry.inflightToken === token;
     const myPromise = (async () => {
       try {
-        const data = await queryFn();
+        const data = await queryFn({ signal: controller.signal });
         if (!isCurrent()) return data;
         entry.state = {
           data,
@@ -369,7 +443,10 @@ var QueryCache = class {
         this.notify(entry);
         throw err;
       } finally {
-        if (isCurrent()) entry.inflight = null;
+        if (isCurrent()) {
+          entry.inflight = null;
+          entry.inflightController = null;
+        }
       }
     })();
     entry.inflight = myPromise;
@@ -391,6 +468,26 @@ var QueryCache = class {
     }
     return invalidated;
   }
+  /**
+   * Перезапускает все записи, матчинг predicate, у которых сохранён
+   * `lastQueryFn` (т.е. их хоть раз кто-то загрузил через `fetch`).
+   * Возвращает promise, который резолвится когда все запросы завершились.
+   * Ошибки отдельных запросов проглатываются — общий promise успешный.
+   */
+  refetchQueries(predicate) {
+    const match = typeof predicate === "function" ? predicate : (k) => matchQueryKey(predicate, k);
+    const promises = [];
+    for (const entry of this.entries.values()) {
+      if (!match(entry.key)) continue;
+      if (!entry.lastQueryFn) continue;
+      promises.push(
+        this.fetch(entry.key, entry.lastQueryFn, { force: true }).catch(
+          () => void 0
+        )
+      );
+    }
+    return Promise.all(promises).then(() => void 0);
+  }
   /**
    * Отменяет «привязку» inflight-промиса к ключу. Сам HTTP-запрос
    * продолжит исполняться (executeRequest не использует AbortSignal),
@@ -401,6 +498,8 @@ var QueryCache = class {
     const match = typeof predicate === "function" ? predicate : (k) => matchQueryKey(predicate, k);
     for (const entry of this.entries.values()) {
       if (match(entry.key) && entry.inflight) {
+        entry.inflightController?.abort();
+        entry.inflightController = null;
         entry.inflight = null;
         entry.inflightToken = void 0;
         if (entry.state.status === "loading") {
@@ -416,12 +515,28 @@ var QueryCache = class {
    */
   remove(predicate) {
     const match = typeof predicate === "function" ? predicate : (k) => matchQueryKey(predicate, k);
+    let removed = false;
     for (const [hash, entry] of [...this.entries]) {
       if (match(entry.key)) {
         if (entry.gcTimer) clearTimeout(entry.gcTimer);
         this.entries.delete(hash);
+        removed = true;
       }
     }
+    if (removed) this.notifyGlobal();
+  }
+  /**
+   * Количество inflight-запросов в кэше, опционально отфильтрованных
+   * по predicate. Используется `useIsFetching()` для глобального
+   * индикатора загрузки.
+   */
+  countFetching(predicate) {
+    const match = !predicate ? () => true : typeof predicate === "function" ? predicate : (k) => matchQueryKey(predicate, k);
+    let n = 0;
+    for (const entry of this.entries.values()) {
+      if (entry.state.status === "loading" && match(entry.key)) n++;
+    }
+    return n;
   }
   /** Только для тестов / DevTools. */
   _debugEntries() {
@@ -480,7 +595,8 @@ var QueryClient = class {
     return this.cache.fetch(key, queryFn, options);
   }
   invalidateQueries(predicate) {
-    this.cache.invalidate(predicate);
+    const hashes = this.cache.invalidate(predicate);
+    if (hashes.length > 0) callLogger("onInvalidate", hashes);
   }
   removeQueries(predicate) {
     this.cache.remove(predicate);
@@ -488,6 +604,19 @@ var QueryClient = class {
   cancelQueries(predicate) {
     this.cache.cancelQueries(predicate);
   }
+  refetchQueries(predicate) {
+    return this.cache.refetchQueries(predicate);
+  }
+  /**
+   * Кладёт запрос в кэш, не пробрасывая ошибки. Подходит для оптимистичной
+   * подгрузки следующего экрана при наведении / долгом тапе.
+   */
+  prefetchQuery(key, queryFn, options) {
+    return this.cache.fetch(key, queryFn, options).then(
+      () => void 0,
+      () => void 0
+    );
+  }
 };
 var globalClient = null;
 function getQueryClient() {
@@ -526,27 +655,37 @@ function createUseFetch(endpoint, fetchConfig) {
     }, [customKey ? hashQueryKey(customKey) : null, serializedParams]);
     const client = getQueryClient();
     const cache = client.cache;
-    const queryFn = useCallback(() => {
-      const parsedParams = serializedParams ? JSON.parse(serializedParams) : void 0;
-      return executeRequest(endpoint, fetchConfig, parsedParams);
-    }, [serializedParams]);
+    const queryFn = useCallback(
+      ({ signal }) => {
+        const parsedParams = serializedParams ? JSON.parse(serializedParams) : void 0;
+        return executeRequest(endpoint, fetchConfig, parsedParams, signal);
+      },
+      [serializedParams]
+    );
     const initialState = cache.getState(queryKey);
     const [, forceRender] = useState(0);
     const rerender = useCallback(() => forceRender((v) => v + 1), []);
     useEffect(() => {
-      if (!enabled) return;
       const unsub = cache.subscribe(queryKey, rerender);
-      return unsub;
-    }, [cache, enabled, hashQueryKey(queryKey), rerender]);
+      return () => {
+        unsub();
+        const state2 = cache._debugEntries().get(hashQueryKey(queryKey));
+        if (state2 && state2.subscribers.size === 0 && state2.inflight) {
+          cache.cancelQueries(queryKey);
+        }
+      };
+    }, [cache, hashQueryKey(queryKey), rerender]);
     const lastNotifiedRef = useRef({});
     const runFetch = useCallback(
       async (force) => {
+        callLogger("onFetchStart", queryKey);
         try {
           const data = await cache.fetch(queryKey, queryFn, {
             staleTime,
             gcTime,
             force
           });
+          callLogger("onFetchSuccess", queryKey, data);
           if (lastNotifiedRef.current.success !== data) {
             lastNotifiedRef.current.success = data;
             handleResponse(
@@ -556,6 +695,7 @@ function createUseFetch(endpoint, fetchConfig) {
             );
           }
         } catch (err) {
+          callLogger("onFetchError", queryKey, err);
           const e = err;
           const hash = `${e.name}:${e.message}`;
           if (lastNotifiedRef.current.errorHash !== hash) {
@@ -639,6 +779,47 @@ function createUseFetch(endpoint, fetchConfig) {
     };
   };
 }
+
+// src/query/mutation-counter.ts
+var MutationCounter = class {
+  constructor() {
+    this.active = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  start(scope) {
+    const id = Symbol("mutation");
+    this.active.set(id, scope);
+    this.notify();
+    return id;
+  }
+  stop(id) {
+    if (this.active.delete(id)) this.notify();
+  }
+  count(predicate) {
+    if (!predicate) return this.active.size;
+    let n = 0;
+    for (const scope of this.active.values()) {
+      if (typeof predicate === "function") {
+        if (predicate(scope)) n++;
+      } else {
+        if (scope && matchQueryKey(predicate, scope)) n++;
+      }
+    }
+    return n;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  notify() {
+    for (const l of this.listeners) l();
+  }
+};
+var mutationCounter = new MutationCounter();
+
+// src/hooks/use-mutation.ts
 function createUseMutation(endpoint, fetchConfig) {
   return (options = {}) => {
     const {
@@ -665,10 +846,21 @@ function createUseMutation(endpoint, fetchConfig) {
       (vars, result) => {
         if (!invalidateKeys) return;
         const client = getQueryClient();
-        const keys = typeof invalidateKeys === "function" ? invalidateKeys(vars, result) : invalidateKeys;
-        if (keys.length === 0) return;
+        if (Array.isArray(invalidateKeys)) {
+          if (invalidateKeys.length === 0) return;
+          client.invalidateQueries(
+            (k) => invalidateKeys.some((prefix) => matchQueryKey(prefix, k))
+          );
+          return;
+        }
+        const out = invalidateKeys(vars, result);
+        if (typeof out === "function") {
+          client.invalidateQueries(out);
+          return;
+        }
+        if (out.length === 0) return;
         client.invalidateQueries(
-          (k) => keys.some((prefix) => matchQueryKey(prefix, k))
+          (k) => out.some((prefix) => matchQueryKey(prefix, k))
         );
       },
       [invalidateKeys]
@@ -679,6 +871,10 @@ function createUseMutation(endpoint, fetchConfig) {
         setIsSuccess(false);
         setIsError(false);
         setError(null);
+        const scope = Array.isArray(invalidateKeys) && invalidateKeys.length > 0 ? invalidateKeys[0] : void 0;
+        const mutationId = mutationCounter.start(scope);
+        const endpointId = buildEndpoint(endpoint, variables);
+        callLogger("onMutationStart", endpointId, variables);
         let context;
         try {
           if (onMutate) {
@@ -689,6 +885,7 @@ function createUseMutation(endpoint, fetchConfig) {
           setData(result);
           if (result.status) {
             setIsSuccess(true);
+            callLogger("onMutationSuccess", endpointId, variables, result);
             if (setQueryData) {
               setQueryData(getQueryClient(), variables, result);
             }
@@ -700,6 +897,7 @@ function createUseMutation(endpoint, fetchConfig) {
             const err = new Error(result.message ?? "Mutation failed");
             setIsError(true);
             setError(err);
+            callLogger("onMutationError", endpointId, variables, err);
             if (onError) {
               await onError(err, variables, context);
             }
@@ -713,6 +911,7 @@ function createUseMutation(endpoint, fetchConfig) {
           setError(error2);
           setIsError(true);
           setIsSuccess(false);
+          callLogger("onMutationError", endpointId, variables, error2);
           if (onError) {
             await onError(error2, variables, context);
           }
@@ -721,6 +920,7 @@ function createUseMutation(endpoint, fetchConfig) {
           }
           throw error2;
         } finally {
+          mutationCounter.stop(mutationId);
           setIsLoading(false);
         }
       },
@@ -797,14 +997,14 @@ function createUsePaginate(endpoint, fetchConfig, options) {
       [keyPrefix, limit]
     );
     const pageQueryFn = useCallback(
-      (page) => () => {
+      (page) => ({ signal }) => {
         const parsedParams = serializedParams ? JSON.parse(serializedParams) : {};
         const requestParams = {
           ...parsedParams,
           page,
           limit
         };
-        return executeRequest(endpoint, fetchConfig, requestParams);
+        return executeRequest(endpoint, fetchConfig, requestParams, signal);
       },
       [serializedParams, limit]
     );
@@ -923,6 +1123,33 @@ function createUsePaginate(endpoint, fetchConfig, options) {
     };
   };
 }
+function useIsFetching(predicate) {
+  const client = getQueryClient();
+  const get = useCallback(
+    () => client.cache.countFetching(predicate),
+    [client.cache, predicate]
+  );
+  const [count, setCount] = useState(get);
+  useEffect(() => {
+    setCount(get());
+    const unsub = client.cache.subscribeAll(() => setCount(get()));
+    return unsub;
+  }, [client.cache, get]);
+  return count;
+}
+function useIsMutating(predicate) {
+  const get = useCallback(
+    () => mutationCounter.count(predicate),
+    [predicate]
+  );
+  const [count, setCount] = useState(get);
+  useEffect(() => {
+    setCount(get());
+    const unsub = mutationCounter.subscribe(() => setCount(get()));
+    return unsub;
+  }, [get]);
+  return count;
+}
 
 // src/query/persist.ts
 function persistQueryClient(options) {
@@ -935,19 +1162,26 @@ function persistQueryClient(options) {
     maxAge,
     version
   } = options;
-  let timer = null;
+  let pendingTimer = null;
   let lastSerialized = null;
+  let unsubscribed = false;
   const persist = async () => {
     const state = client.cache.dehydrate(allowList);
-    if (state.queries.length === 0) {
-      return;
-    }
+    if (state.queries.length === 0) return;
     const snap = { version, savedAt: Date.now(), state };
     const serialized = JSON.stringify(snap);
     if (serialized === lastSerialized) return;
     lastSerialized = serialized;
     await storage.setItem(storageKey, serialized);
   };
+  const scheduleWrite = () => {
+    if (unsubscribed) return;
+    if (pendingTimer) return;
+    pendingTimer = setTimeout(() => {
+      pendingTimer = null;
+      void persist();
+    }, throttleMs);
+  };
   const restore = async () => {
     const raw = await storage.getItem(storageKey);
     if (!raw) return;
@@ -966,15 +1200,17 @@ function persistQueryClient(options) {
       await storage.removeItem(storageKey);
     }
   };
-  timer = setInterval(() => {
-    void persist();
-  }, throttleMs);
+  const unsubscribeFromCache = client.cache.subscribeAll(scheduleWrite);
   return {
     restore,
     persist,
     unsubscribe: () => {
-      if (timer) clearInterval(timer);
-      timer = null;
+      unsubscribed = true;
+      unsubscribeFromCache();
+      if (pendingTimer) {
+        clearTimeout(pendingTimer);
+        pendingTimer = null;
+      }
     }
   };
 }
@@ -1075,6 +1311,6 @@ function apiPaginate(endpoint, fetchConfig = {}, options) {
 }
 var index_default = apiClient;
 
-export { ApiClientProvider, ApiError, QueryCache, QueryClient, apiMutation, apiPaginate, configureApiClient, index_default as default, focusManager, getConfig, getQueryClient, hashQueryKey, inspectCache, invalidateAll, isConfigured, matchQueryKey, onlineManager, persistQueryClient, setQueryClient, summarizeCache, useQueryClient };
+export { ApiClientProvider, ApiError, QueryCache, QueryClient, apiMutation, apiPaginate, businessErrorToApiError, configureApiClient, index_default as default, focusManager, getConfig, getQueryClient, hashQueryKey, inspectCache, invalidateAll, isConfigured, matchQueryKey, onlineManager, persistQueryClient, setQueryClient, summarizeCache, toApiError, useIsFetching, useIsMutating, useQueryClient };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map