mbt-api-client 1.0.0

package/dist/index.cjs

@@ -0,0 +1,561 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiClientContext: () => ApiClientContext,
+  ApiClientProvider: () => ApiClientProvider,
+  TokenRefreshManager: () => TokenRefreshManager,
+  createApiClient: () => createApiClient,
+  createTokenRefreshManager: () => createTokenRefreshManager,
+  useApiClient: () => useApiClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/api-client.ts
+var import_axios = __toESM(require("axios"), 1);
+var import_react = require("react");
+
+// src/token-refresh.ts
+var defaultGetAccessToken = () => localStorage.getItem("accessToken");
+var defaultGetRefreshToken = () => localStorage.getItem("refreshToken");
+var defaultSetTokens = (accessToken, refreshToken) => {
+  localStorage.setItem("accessToken", accessToken);
+  if (refreshToken) {
+    localStorage.setItem("refreshToken", refreshToken);
+  }
+};
+var defaultClearTokens = () => {
+  localStorage.removeItem("accessToken");
+  localStorage.removeItem("refreshToken");
+};
+var defaultNavigateToLogin = () => {
+  defaultClearTokens();
+  window.location.href = "#/login";
+};
+var TokenRefreshManager = class {
+  /**
+   * Создаёт новый экземпляр TokenRefreshManager
+   *
+   * @param config - Конфигурация менеджера
+   *
+   * @example
+   * ```typescript
+   * const manager = new TokenRefreshManager({
+   *   refreshTokenFn: myRefreshFunction,
+   *   onNavigateToLogin: () => router.push('/login'),
+   * });
+   * ```
+   */
+  constructor(config) {
+    this.isRefreshing = false;
+    this.refreshPromise = null;
+    this.queuedRequests = [];
+    this.config = {
+      refreshTokenFn: config.refreshTokenFn,
+      onNavigateToLogin: config.onNavigateToLogin ?? defaultNavigateToLogin,
+      getAccessToken: config.getAccessToken ?? defaultGetAccessToken,
+      getRefreshToken: config.getRefreshToken ?? defaultGetRefreshToken,
+      setTokens: config.setTokens ?? defaultSetTokens,
+      clearTokens: config.clearTokens ?? defaultClearTokens
+    };
+  }
+  /**
+   * Получает текущий access токен
+   *
+   * @returns Access токен или null, если токен отсутствует
+   *
+   * @example
+   * ```typescript
+   * const token = manager.getAccessToken();
+   * if (token) {
+   *   headers.Authorization = `Bearer ${token}`;
+   * }
+   * ```
+   */
+  getAccessToken() {
+    return this.config.getAccessToken();
+  }
+  /**
+   * Получает текущий refresh токен
+   *
+   * @returns Refresh токен или null, если токен отсутствует
+   */
+  getRefreshToken() {
+    return this.config.getRefreshToken();
+  }
+  /**
+   * Проверяет, идёт ли в данный момент процесс обновления токена
+   *
+   * Используйте для определения, нужно ли ставить запрос в очередь
+   * или инициировать новое обновление.
+   *
+   * @returns `true` если обновление в процессе, `false` если нет
+   *
+   * @example
+   * ```typescript
+   * if (manager.isRefreshInProgress()) {
+   *   // Ждём завершения текущего обновления
+   *   const newToken = await manager.waitForTokenRefresh();
+   * } else {
+   *   // Инициируем новое обновление
+   *   await manager.refreshToken();
+   * }
+   * ```
+   */
+  isRefreshInProgress() {
+    return this.isRefreshing;
+  }
+  /**
+   * Добавляет запрос в очередь ожидания обновления токена
+   *
+   * Возвращает промис, который разрешится с новым токеном после
+   * успешного обновления или будет отклонён при ошибке.
+   *
+   * @returns Промис с новым access токеном
+   *
+   * @example
+   * ```typescript
+   * // В response interceptor при множественных 401
+   * if (manager.isRefreshInProgress()) {
+   *   try {
+   *     const newToken = await manager.waitForTokenRefresh();
+   *     // Повторить запрос с новым токеном
+   *   } catch {
+   *     // Обновление не удалось
+   *   }
+   * }
+   * ```
+   */
+  waitForTokenRefresh() {
+    return new Promise((resolve, reject) => {
+      this.queuedRequests.push({ resolve, reject });
+    });
+  }
+  /**
+   * Выполняет обновление токена
+   *
+   * Если обновление уже в процессе, вернёт существующий промис.
+   * После обновления уведомляет все запросы в очереди.
+   *
+   * @returns Промис с результатом обновления
+   *
+   * @example
+   * ```typescript
+   * const result = await manager.refreshToken();
+   * if (result.ok) {
+   *   console.log('Новый токен:', result.accessToken);
+   * } else {
+   *   console.log('Ошибка обновления токена');
+   * }
+   * ```
+   */
+  async refreshToken() {
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.isRefreshing = true;
+    this.refreshPromise = this.performRefresh().finally(() => {
+      setTimeout(() => {
+        this.refreshPromise = null;
+      }, 100);
+    });
+    return this.refreshPromise;
+  }
+  /**
+   * Обрабатывает ошибку 401 — либо обновляет токен, либо перенаправляет на логин
+   *
+   * Основной метод для использования в interceptors. Автоматически:
+   * - Перенаправляет на логин при невалидном токене
+   * - Ставит запрос в очередь, если обновление уже идёт
+   * - Инициирует обновление, если ещё не запущено
+   *
+   * @param isInvalidToken - Если true, токен считается невалидным и будет выполнен переход на логин
+   * @returns Промис с новым access токеном или null при ошибке
+   *
+   * @example
+   * ```typescript
+   * // В axios response interceptor
+   * if (error.response?.status === 401) {
+   *   const isInvalid = error.response.data?.message === 'Invalid token';
+   *   const newToken = await manager.handle401(isInvalid);
+   *
+   *   if (newToken) {
+   *     // Повторить запрос с новым токеном
+   *     error.config.headers.Authorization = `Bearer ${newToken}`;
+   *     return axios(error.config);
+   *   }
+   *   // newToken === null означает переход на логин
+   * }
+   * ```
+   */
+  async handle401(isInvalidToken = false) {
+    if (isInvalidToken) {
+      this.config.onNavigateToLogin();
+      return null;
+    }
+    if (this.isRefreshing) {
+      return this.waitForTokenRefresh();
+    }
+    const result = await this.refreshToken();
+    if (!result.ok) {
+      this.config.onNavigateToLogin();
+      return null;
+    }
+    return result.accessToken || this.config.getAccessToken();
+  }
+  /**
+   * Принудительно перенаправляет на страницу логина
+   *
+   * Вызывает колбэк onNavigateToLogin из конфигурации.
+   *
+   * @example
+   * ```typescript
+   * // При необходимости принудительного выхода
+   * manager.navigateToLogin();
+   * ```
+   */
+  navigateToLogin() {
+    this.config.onNavigateToLogin();
+  }
+  /**
+   * Сбрасывает внутреннее состояние менеджера
+   *
+   * Полезно для тестирования или при необходимости
+   * принудительно сбросить очередь запросов.
+   *
+   * @example
+   * ```typescript
+   * // В тестах
+   * beforeEach(() => {
+   *   manager.reset();
+   * });
+   * ```
+   */
+  reset() {
+    this.isRefreshing = false;
+    this.refreshPromise = null;
+    this.queuedRequests = [];
+  }
+  async performRefresh() {
+    try {
+      const result = await this.config.refreshTokenFn();
+      if (result.ok && result.accessToken) {
+        this.config.setTokens(result.accessToken, result.refreshToken);
+        this.notifyQueueSuccess(result.accessToken);
+      } else {
+        this.notifyQueueFailure(new Error("Token refresh failed"));
+      }
+      this.isRefreshing = false;
+      return result;
+    } catch (error) {
+      this.isRefreshing = false;
+      this.notifyQueueFailure(error);
+      return { ok: false };
+    }
+  }
+  notifyQueueSuccess(newToken) {
+    this.queuedRequests.forEach(({ resolve }) => resolve(newToken));
+    this.queuedRequests = [];
+  }
+  notifyQueueFailure(error) {
+    this.queuedRequests.forEach(({ reject }) => reject(error));
+    this.queuedRequests = [];
+  }
+};
+var createTokenRefreshManager = (config) => {
+  return new TokenRefreshManager(config);
+};
+
+// src/api-client.ts
+var RETRY_KEY = /* @__PURE__ */ Symbol("retry");
+var defaultNavigateToLogin2 = () => {
+  localStorage.removeItem("accessToken");
+  localStorage.removeItem("refreshToken");
+  window.location.href = "#/login";
+};
+var defaultDecodeJwt = (token) => {
+  try {
+    const base64Url = token.split(".")[1];
+    const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+    const jsonPayload = decodeURIComponent(
+      atob(base64).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("")
+    );
+    return JSON.parse(jsonPayload);
+  } catch {
+    return null;
+  }
+};
+var createAxiosInstance = (baseUrl, tokenRefreshManager, onNavigateToLogin, timeout, decodeJwt) => {
+  const instance = import_axios.default.create({
+    baseURL: baseUrl,
+    timeout,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  instance.interceptors.request.use(
+    (requestConfig) => {
+      const isRefreshRequest = requestConfig.url?.includes("auth/refresh-token");
+      const accessToken = tokenRefreshManager.getAccessToken();
+      const refreshToken = tokenRefreshManager.getRefreshToken();
+      const token = isRefreshRequest ? refreshToken : accessToken;
+      if (token) {
+        Object.assign(requestConfig.headers, {
+          Authorization: `Bearer ${token}`
+        });
+      }
+      const decodedToken = decodeJwt(accessToken || "");
+      if (decodedToken?.userId) {
+        Object.assign(requestConfig.headers, {
+          "X-User-Id": decodedToken.userId
+        });
+      }
+      return requestConfig;
+    },
+    (error) => Promise.reject(error)
+  );
+  instance.interceptors.response.use(
+    (response) => response,
+    async (error) => {
+      const originalRequest = error.config;
+      if (!originalRequest) {
+        return Promise.reject(error);
+      }
+      const isRefreshRequest = originalRequest.url?.includes("auth/refresh-token");
+      if (error.response?.status === 401) {
+        const responseData = error.response?.data;
+        const isInvalidToken = responseData?.message === "Invalid token";
+        if (isInvalidToken) {
+          onNavigateToLogin();
+          return Promise.reject(error);
+        }
+        if (isRefreshRequest) {
+          onNavigateToLogin();
+          return Promise.reject(error);
+        }
+        if (originalRequest[RETRY_KEY]) {
+          onNavigateToLogin();
+          return Promise.reject(error);
+        }
+        if (tokenRefreshManager.isRefreshInProgress()) {
+          try {
+            const newToken = await tokenRefreshManager.waitForTokenRefresh();
+            const retryConfig2 = { ...originalRequest };
+            Object.assign(retryConfig2.headers, {
+              Authorization: `Bearer ${newToken}`
+            });
+            return instance(retryConfig2);
+          } catch {
+            return Promise.reject(error);
+          }
+        }
+        const retryConfig = {
+          ...originalRequest,
+          [RETRY_KEY]: true
+        };
+        try {
+          const newToken = await tokenRefreshManager.handle401(false);
+          if (!newToken) {
+            return Promise.reject(new Error("Failed to refresh token"));
+          }
+          Object.assign(retryConfig.headers, {
+            Authorization: `Bearer ${newToken}`
+          });
+          return instance(retryConfig);
+        } catch (refreshError) {
+          onNavigateToLogin();
+          return Promise.reject(refreshError);
+        }
+      }
+      if (error.response?.status === 403) {
+        onNavigateToLogin();
+        return Promise.reject(error);
+      }
+      if (error.response?.status === 400 && isRefreshRequest) {
+        await new Promise((resolve) => {
+          setTimeout(resolve, 1e3);
+        });
+        const newToken = tokenRefreshManager.getAccessToken();
+        if (newToken) {
+          const retryConfig = { ...originalRequest };
+          Object.assign(retryConfig.headers, {
+            Authorization: `Bearer ${newToken}`
+          });
+          return instance(retryConfig);
+        }
+        onNavigateToLogin();
+        return Promise.reject(new Error("Failed to refresh token"));
+      }
+      return Promise.reject(error);
+    }
+  );
+  return instance;
+};
+var createApiService = (axiosInstance) => {
+  return {
+    get: (url, config) => {
+      const cacheBuster = `${url.includes("?") ? "&" : "?"}_t=${Date.now()}`;
+      return axiosInstance.get(url + cacheBuster, config).then((response) => response.data);
+    },
+    post: (url, data, config) => axiosInstance.post(url, data, config).then((response) => response.data),
+    put: (url, data, config) => axiosInstance.put(url, data, config).then((response) => response.data),
+    delete: (url, config) => axiosInstance.delete(url, config).then((response) => response.data),
+    axiosInstance
+  };
+};
+var createApiClient = (config) => {
+  const {
+    urls,
+    onNavigateToLogin = defaultNavigateToLogin2,
+    timeout = 1e4,
+    decodeJwt = defaultDecodeJwt
+  } = config;
+  const authAxiosInstance = import_axios.default.create({
+    baseURL: urls.authService,
+    timeout,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const refreshTokenFn = async () => {
+    try {
+      const refreshToken = localStorage.getItem("refreshToken");
+      if (!refreshToken) {
+        return { ok: false };
+      }
+      const response = await authAxiosInstance.post(
+        "/auth/refresh-token",
+        {},
+        {
+          headers: {
+            Authorization: `Bearer ${refreshToken}`
+          }
+        }
+      );
+      const { accessToken, refreshToken: newRefreshToken } = response.data;
+      return {
+        ok: true,
+        accessToken,
+        refreshToken: newRefreshToken
+      };
+    } catch {
+      return { ok: false };
+    }
+  };
+  const tokenRefreshManager = createTokenRefreshManager({
+    refreshTokenFn,
+    onNavigateToLogin
+  });
+  authAxiosInstance.interceptors.request.use(
+    (requestConfig) => {
+      const isRefreshRequest = requestConfig.url?.includes("auth/refresh-token");
+      const accessToken = tokenRefreshManager.getAccessToken();
+      const refreshToken = tokenRefreshManager.getRefreshToken();
+      const token = isRefreshRequest ? refreshToken : accessToken;
+      if (token && !requestConfig.headers.Authorization) {
+        Object.assign(requestConfig.headers, {
+          Authorization: `Bearer ${token}`
+        });
+      }
+      const decodedToken = decodeJwt(accessToken || "");
+      if (decodedToken?.userId) {
+        Object.assign(requestConfig.headers, {
+          "X-User-Id": decodedToken.userId
+        });
+      }
+      return requestConfig;
+    },
+    (error) => Promise.reject(error)
+  );
+  const userProgressAxiosInstance = createAxiosInstance(
+    urls.userProgressService,
+    tokenRefreshManager,
+    onNavigateToLogin,
+    timeout,
+    decodeJwt
+  );
+  const recommendationAxiosInstance = createAxiosInstance(
+    urls.recommendationService,
+    tokenRefreshManager,
+    onNavigateToLogin,
+    timeout,
+    decodeJwt
+  );
+  const partnerManagerAxiosInstance = createAxiosInstance(
+    urls.partnerManager,
+    tokenRefreshManager,
+    onNavigateToLogin,
+    timeout,
+    decodeJwt
+  );
+  const puzzleControllerAxiosInstance = createAxiosInstance(
+    urls.puzzleController,
+    tokenRefreshManager,
+    onNavigateToLogin,
+    timeout,
+    decodeJwt
+  );
+  const monolithAxiosInstance = createAxiosInstance(
+    urls.monolith,
+    tokenRefreshManager,
+    onNavigateToLogin,
+    timeout,
+    decodeJwt
+  );
+  return {
+    authService: createApiService(authAxiosInstance),
+    userProgressService: createApiService(userProgressAxiosInstance),
+    recommendationService: createApiService(recommendationAxiosInstance),
+    partnerManager: createApiService(partnerManagerAxiosInstance),
+    puzzleController: createApiService(puzzleControllerAxiosInstance),
+    monolith: createApiService(monolithAxiosInstance),
+    tokenRefreshManager
+  };
+};
+var ApiClientContext = (0, import_react.createContext)(null);
+var useApiClient = () => {
+  const context = (0, import_react.useContext)(ApiClientContext);
+  if (!context) {
+    throw new Error("useApiClient must be used within ApiClientProvider");
+  }
+  return context;
+};
+var ApiClientProvider = ApiClientContext.Provider;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiClientContext,
+  ApiClientProvider,
+  TokenRefreshManager,
+  createApiClient,
+  createTokenRefreshManager,
+  useApiClient
+});
+//# sourceMappingURL=index.cjs.map