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

package/dist/index.js

@@ -36,6 +36,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) {
@@ -44,7 +90,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 {
@@ -55,7 +101,8 @@ async function executeRequest(endpoint, fetchConfig, params) {
         params: {
           ...requestConfig.requestParams,
           ...params
-        }
+        },
+        signal
       });
     } else {
       response = await config.httpClient.request(url, {
@@ -63,38 +110,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 {
@@ -117,6 +155,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() {
@@ -255,6 +308,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);
@@ -271,7 +339,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
       };
@@ -319,6 +389,7 @@ var QueryCache = class {
   }
   notify(entry) {
     for (const listener of entry.subscribers) listener();
+    this.notifyGlobal();
   }
   scheduleGc(entry) {
     if (entry.gcTimer) clearTimeout(entry.gcTimer);
@@ -341,18 +412,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,
@@ -373,7 +447,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;
@@ -395,6 +472,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),
@@ -405,6 +502,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") {
@@ -420,12 +519,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() {
@@ -484,7 +599,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);
@@ -492,6 +608,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() {
@@ -530,27 +659,37 @@ function createUseFetch(endpoint, fetchConfig) {
     }, [customKey ? hashQueryKey(customKey) : null, serializedParams]);
     const client = getQueryClient();
     const cache = client.cache;
-    const queryFn = react.useCallback(() => {
-      const parsedParams = serializedParams ? JSON.parse(serializedParams) : void 0;
-      return executeRequest(endpoint, fetchConfig, parsedParams);
-    }, [serializedParams]);
+    const queryFn = react.useCallback(
+      ({ signal }) => {
+        const parsedParams = serializedParams ? JSON.parse(serializedParams) : void 0;
+        return executeRequest(endpoint, fetchConfig, parsedParams, signal);
+      },
+      [serializedParams]
+    );
     const initialState = cache.getState(queryKey);
     const [, forceRender] = react.useState(0);
     const rerender = react.useCallback(() => forceRender((v) => v + 1), []);
     react.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 = react.useRef({});
     const runFetch = react.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(
@@ -560,6 +699,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) {
@@ -643,6 +783,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 {
@@ -669,10 +850,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]
@@ -683,6 +875,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) {
@@ -693,6 +889,7 @@ function createUseMutation(endpoint, fetchConfig) {
           setData(result);
           if (result.status) {
             setIsSuccess(true);
+            callLogger("onMutationSuccess", endpointId, variables, result);
             if (setQueryData) {
               setQueryData(getQueryClient(), variables, result);
             }
@@ -704,6 +901,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);
             }
@@ -717,6 +915,7 @@ function createUseMutation(endpoint, fetchConfig) {
           setError(error2);
           setIsError(true);
           setIsSuccess(false);
+          callLogger("onMutationError", endpointId, variables, error2);
           if (onError) {
             await onError(error2, variables, context);
           }
@@ -725,6 +924,7 @@ function createUseMutation(endpoint, fetchConfig) {
           }
           throw error2;
         } finally {
+          mutationCounter.stop(mutationId);
           setIsLoading(false);
         }
       },
@@ -801,14 +1001,14 @@ function createUsePaginate(endpoint, fetchConfig, options) {
       [keyPrefix, limit]
     );
     const pageQueryFn = react.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]
     );
@@ -927,6 +1127,33 @@ function createUsePaginate(endpoint, fetchConfig, options) {
     };
   };
 }
+function useIsFetching(predicate) {
+  const client = getQueryClient();
+  const get = react.useCallback(
+    () => client.cache.countFetching(predicate),
+    [client.cache, predicate]
+  );
+  const [count, setCount] = react.useState(get);
+  react.useEffect(() => {
+    setCount(get());
+    const unsub = client.cache.subscribeAll(() => setCount(get()));
+    return unsub;
+  }, [client.cache, get]);
+  return count;
+}
+function useIsMutating(predicate) {
+  const get = react.useCallback(
+    () => mutationCounter.count(predicate),
+    [predicate]
+  );
+  const [count, setCount] = react.useState(get);
+  react.useEffect(() => {
+    setCount(get());
+    const unsub = mutationCounter.subscribe(() => setCount(get()));
+    return unsub;
+  }, [get]);
+  return count;
+}
 
 // src/query/persist.ts
 function persistQueryClient(options) {
@@ -939,19 +1166,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;
@@ -970,15 +1204,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;
+      }
     }
   };
 }
@@ -1085,6 +1321,7 @@ exports.QueryCache = QueryCache;
 exports.QueryClient = QueryClient;
 exports.apiMutation = apiMutation;
 exports.apiPaginate = apiPaginate;
+exports.businessErrorToApiError = businessErrorToApiError;
 exports.configureApiClient = configureApiClient;
 exports.default = index_default;
 exports.focusManager = focusManager;
@@ -1099,6 +1336,9 @@ exports.onlineManager = onlineManager;
 exports.persistQueryClient = persistQueryClient;
 exports.setQueryClient = setQueryClient;
 exports.summarizeCache = summarizeCache;
+exports.toApiError = toApiError;
+exports.useIsFetching = useIsFetching;
+exports.useIsMutating = useIsMutating;
 exports.useQueryClient = useQueryClient;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map