@krymskyimaksym/react-api-client 2.0.0-beta.1 → 2.0.0-beta.3

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;
@@ -151,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() {
@@ -322,6 +337,7 @@ var QueryCache = class {
         inflight: null,
         inflightController: null,
         gcTimer: null,
+        lastQueryFn: null,
         staleTime: staleTime ?? DEFAULT_STALE_TIME,
         gcTime: gcTime ?? DEFAULT_GC_TIME
       };
@@ -392,6 +408,7 @@ 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;
     }
@@ -451,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),
@@ -488,6 +525,19 @@ var QueryCache = class {
     }
     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() {
     return this.entries;
@@ -545,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);
@@ -553,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() {
@@ -614,12 +678,14 @@ function createUseFetch(endpoint, fetchConfig) {
     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(
@@ -629,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) {
@@ -712,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 {
@@ -738,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]
@@ -752,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) {
@@ -762,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);
             }
@@ -773,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);
             }
@@ -786,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);
           }
@@ -794,6 +920,7 @@ function createUseMutation(endpoint, fetchConfig) {
           }
           throw error2;
         } finally {
+          mutationCounter.stop(mutationId);
           setIsLoading(false);
         }
       },
@@ -996,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) {
@@ -1157,6 +1311,6 @@ function apiPaginate(endpoint, fetchConfig = {}, options) {
 }
 var index_default = apiClient;
 
-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, 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