@gajay/axios-refresh-core 1.1.0

package/dist/index.cjs

@@ -0,0 +1,245 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createAxiosRefresh: () => createAxiosRefresh
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/createCircuitBreaker.ts
+var createCircuitBreaker = (config) => {
+  if (!config?.enabled) {
+    return {
+      canExecute: () => true,
+      onSuccess: () => {
+      },
+      onFailure: () => {
+      },
+      getState: () => "CLOSED"
+    };
+  }
+  let state = "CLOSED";
+  let failures = 0;
+  let successes = 0;
+  let nextTry = 0;
+  const failureThreshold = config.failureThreshold ?? 3;
+  const successThreshold = config.successThreshold ?? 1;
+  const timeoutMs = config.timeoutMs ?? 1e4;
+  const now = () => Date.now();
+  const canExecute = () => {
+    if (state === "OPEN") {
+      if (now() >= nextTry) {
+        state = "HALF_OPEN";
+        return true;
+      }
+      return false;
+    }
+    return true;
+  };
+  const onSuccess = () => {
+    if (state === "HALF_OPEN") {
+      successes++;
+      if (successes >= successThreshold) {
+        state = "CLOSED";
+        failures = 0;
+        successes = 0;
+      }
+    } else {
+      failures = 0;
+    }
+  };
+  const onFailure = () => {
+    failures++;
+    if (failures >= failureThreshold) {
+      state = "OPEN";
+      nextTry = now() + timeoutMs;
+    }
+  };
+  return {
+    canExecute,
+    onSuccess,
+    onFailure,
+    getState: () => state
+  };
+};
+
+// src/createCooldownLock.ts
+var createCooldownLock = (config) => {
+  if (!config?.enabled) {
+    return {
+      canProceed: async () => true,
+      activate: () => {
+      }
+    };
+  }
+  let lockedUntil = 0;
+  return {
+    canProceed: async () => {
+      const now = Date.now();
+      if (now >= lockedUntil) return true;
+      if (config.strategy === "wait") {
+        await new Promise(
+          (r) => setTimeout(r, lockedUntil - now)
+        );
+        return true;
+      }
+      return false;
+    },
+    activate: () => {
+      lockedUntil = Date.now() + (config.durationMs ?? 3e3);
+    }
+  };
+};
+
+// src/createCrossTabSync.ts
+var createCrossTabSync = () => {
+  if (typeof window === "undefined" || typeof globalThis.BroadcastChannel === "undefined") {
+    return {
+      broadcast: () => {
+      },
+      listen: () => {
+      }
+    };
+  }
+  const channel = new globalThis.BroadcastChannel(
+    "axios-refresh"
+  );
+  return {
+    broadcast: (token) => {
+      channel.postMessage({ token });
+    },
+    listen: (cb) => {
+      channel.addEventListener("message", (e) => {
+        if (e.data?.token) cb(e.data.token);
+      });
+    }
+  };
+};
+
+// src/createDevtoolsBridge.ts
+var createDevtoolsBridge = () => {
+  if (typeof window === "undefined") return null;
+  const w = window;
+  if (!w.__AXIOS_REFRESH_DEVTOOLS__) {
+    w.__AXIOS_REFRESH_DEVTOOLS__ = {
+      events: [],
+      emit(e) {
+        this.events.push(e);
+      }
+    };
+  }
+  return w.__AXIOS_REFRESH_DEVTOOLS__;
+};
+
+// src/retryRequest.ts
+var retryRequest = async (fn, retries = 0) => {
+  let attempt = 0;
+  while (attempt <= retries) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (attempt === retries) throw e;
+      attempt++;
+    }
+  }
+};
+
+// src/anomaly.ts
+var history = [];
+var detectAnomaly = async (config) => {
+  if (!config) return;
+  const now = Date.now();
+  history.push(now);
+  history = history.filter((t) => now - t < 6e4);
+  if (history.length > (config.maxPerMinute ?? 5)) {
+    if (config.reportToServer && config.reportEndpoint) {
+      await fetch(config.reportEndpoint, {
+        method: "POST",
+        body: JSON.stringify({
+          type: "excessive_refresh",
+          timestamp: now
+        })
+      });
+    }
+  }
+};
+
+// src/createAxiosRefresh.ts
+var createAxiosRefresh = (config) => {
+  const breaker = createCircuitBreaker(config.circuitBreaker);
+  const cooldown = createCooldownLock(config.cooldown);
+  const crossTab = createCrossTabSync();
+  const devtools = config.devtools?.enabled && createDevtoolsBridge();
+  let isRefreshing = false;
+  let queue = [];
+  const processQueue = (token) => {
+    queue.forEach((cb) => cb(token));
+    queue = [];
+  };
+  crossTab.listen((token) => {
+    config.setAccessToken?.(token);
+  });
+  const refresh = async () => {
+    if (!breaker.canExecute())
+      throw new Error("Circuit OPEN");
+    if (!await cooldown.canProceed())
+      throw new Error("Cooldown");
+    if (isRefreshing)
+      return new Promise((res) => queue.push(res));
+    isRefreshing = true;
+    try {
+      const token = await retryRequest(
+        () => config.refreshTokenFn(),
+        config.retry?.maxRetries ?? 0
+      );
+      breaker.onSuccess();
+      cooldown.activate();
+      config.setAccessToken?.(token);
+      crossTab.broadcast(token);
+      processQueue(token);
+      await detectAnomaly(config.anomaly);
+      devtools?.emit({ type: "refresh_success" });
+      return token;
+    } catch (e) {
+      breaker.onFailure();
+      cooldown.activate();
+      config.logout?.();
+      throw e;
+    } finally {
+      isRefreshing = false;
+    }
+  };
+  config.axiosInstance.interceptors.response.use(
+    (r) => r,
+    async (error) => {
+      if (error.response?.status === 401) {
+        const token = await refresh();
+        error.config.headers.Authorization = token;
+        return config.axiosInstance(error.config);
+      }
+      return Promise.reject(error);
+    }
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAxiosRefresh
+});

package/dist/index.d.cts

@@ -0,0 +1,38 @@
+import { AxiosInstance } from 'axios';
+
+interface CircuitBreakerConfig {
+    enabled?: boolean;
+    failureThreshold?: number;
+    successThreshold?: number;
+    timeoutMs?: number;
+}
+interface CooldownConfig {
+    enabled?: boolean;
+    durationMs?: number;
+    strategy?: "reject" | "wait";
+}
+interface AnomalyConfig {
+    maxPerMinute?: number;
+    reportToServer?: boolean;
+    reportEndpoint?: string;
+}
+interface CreateAxiosRefreshConfig {
+    axiosInstance: AxiosInstance;
+    refreshTokenFn: () => Promise<string>;
+    setAccessToken?: (token: string) => void;
+    logout?: () => void;
+    retry?: {
+        enabled?: boolean;
+        maxRetries?: number;
+    };
+    circuitBreaker?: CircuitBreakerConfig;
+    cooldown?: CooldownConfig;
+    anomaly?: AnomalyConfig;
+    devtools?: {
+        enabled?: boolean;
+    };
+}
+
+declare const createAxiosRefresh: (config: any) => void;
+
+export { type AnomalyConfig, type CircuitBreakerConfig, type CooldownConfig, type CreateAxiosRefreshConfig, createAxiosRefresh };

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+import { AxiosInstance } from 'axios';
+
+interface CircuitBreakerConfig {
+    enabled?: boolean;
+    failureThreshold?: number;
+    successThreshold?: number;
+    timeoutMs?: number;
+}
+interface CooldownConfig {
+    enabled?: boolean;
+    durationMs?: number;
+    strategy?: "reject" | "wait";
+}
+interface AnomalyConfig {
+    maxPerMinute?: number;
+    reportToServer?: boolean;
+    reportEndpoint?: string;
+}
+interface CreateAxiosRefreshConfig {
+    axiosInstance: AxiosInstance;
+    refreshTokenFn: () => Promise<string>;
+    setAccessToken?: (token: string) => void;
+    logout?: () => void;
+    retry?: {
+        enabled?: boolean;
+        maxRetries?: number;
+    };
+    circuitBreaker?: CircuitBreakerConfig;
+    cooldown?: CooldownConfig;
+    anomaly?: AnomalyConfig;
+    devtools?: {
+        enabled?: boolean;
+    };
+}
+
+declare const createAxiosRefresh: (config: any) => void;
+
+export { type AnomalyConfig, type CircuitBreakerConfig, type CooldownConfig, type CreateAxiosRefreshConfig, createAxiosRefresh };

package/dist/index.js

@@ -0,0 +1,218 @@
+// src/createCircuitBreaker.ts
+var createCircuitBreaker = (config) => {
+  if (!config?.enabled) {
+    return {
+      canExecute: () => true,
+      onSuccess: () => {
+      },
+      onFailure: () => {
+      },
+      getState: () => "CLOSED"
+    };
+  }
+  let state = "CLOSED";
+  let failures = 0;
+  let successes = 0;
+  let nextTry = 0;
+  const failureThreshold = config.failureThreshold ?? 3;
+  const successThreshold = config.successThreshold ?? 1;
+  const timeoutMs = config.timeoutMs ?? 1e4;
+  const now = () => Date.now();
+  const canExecute = () => {
+    if (state === "OPEN") {
+      if (now() >= nextTry) {
+        state = "HALF_OPEN";
+        return true;
+      }
+      return false;
+    }
+    return true;
+  };
+  const onSuccess = () => {
+    if (state === "HALF_OPEN") {
+      successes++;
+      if (successes >= successThreshold) {
+        state = "CLOSED";
+        failures = 0;
+        successes = 0;
+      }
+    } else {
+      failures = 0;
+    }
+  };
+  const onFailure = () => {
+    failures++;
+    if (failures >= failureThreshold) {
+      state = "OPEN";
+      nextTry = now() + timeoutMs;
+    }
+  };
+  return {
+    canExecute,
+    onSuccess,
+    onFailure,
+    getState: () => state
+  };
+};
+
+// src/createCooldownLock.ts
+var createCooldownLock = (config) => {
+  if (!config?.enabled) {
+    return {
+      canProceed: async () => true,
+      activate: () => {
+      }
+    };
+  }
+  let lockedUntil = 0;
+  return {
+    canProceed: async () => {
+      const now = Date.now();
+      if (now >= lockedUntil) return true;
+      if (config.strategy === "wait") {
+        await new Promise(
+          (r) => setTimeout(r, lockedUntil - now)
+        );
+        return true;
+      }
+      return false;
+    },
+    activate: () => {
+      lockedUntil = Date.now() + (config.durationMs ?? 3e3);
+    }
+  };
+};
+
+// src/createCrossTabSync.ts
+var createCrossTabSync = () => {
+  if (typeof window === "undefined" || typeof globalThis.BroadcastChannel === "undefined") {
+    return {
+      broadcast: () => {
+      },
+      listen: () => {
+      }
+    };
+  }
+  const channel = new globalThis.BroadcastChannel(
+    "axios-refresh"
+  );
+  return {
+    broadcast: (token) => {
+      channel.postMessage({ token });
+    },
+    listen: (cb) => {
+      channel.addEventListener("message", (e) => {
+        if (e.data?.token) cb(e.data.token);
+      });
+    }
+  };
+};
+
+// src/createDevtoolsBridge.ts
+var createDevtoolsBridge = () => {
+  if (typeof window === "undefined") return null;
+  const w = window;
+  if (!w.__AXIOS_REFRESH_DEVTOOLS__) {
+    w.__AXIOS_REFRESH_DEVTOOLS__ = {
+      events: [],
+      emit(e) {
+        this.events.push(e);
+      }
+    };
+  }
+  return w.__AXIOS_REFRESH_DEVTOOLS__;
+};
+
+// src/retryRequest.ts
+var retryRequest = async (fn, retries = 0) => {
+  let attempt = 0;
+  while (attempt <= retries) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (attempt === retries) throw e;
+      attempt++;
+    }
+  }
+};
+
+// src/anomaly.ts
+var history = [];
+var detectAnomaly = async (config) => {
+  if (!config) return;
+  const now = Date.now();
+  history.push(now);
+  history = history.filter((t) => now - t < 6e4);
+  if (history.length > (config.maxPerMinute ?? 5)) {
+    if (config.reportToServer && config.reportEndpoint) {
+      await fetch(config.reportEndpoint, {
+        method: "POST",
+        body: JSON.stringify({
+          type: "excessive_refresh",
+          timestamp: now
+        })
+      });
+    }
+  }
+};
+
+// src/createAxiosRefresh.ts
+var createAxiosRefresh = (config) => {
+  const breaker = createCircuitBreaker(config.circuitBreaker);
+  const cooldown = createCooldownLock(config.cooldown);
+  const crossTab = createCrossTabSync();
+  const devtools = config.devtools?.enabled && createDevtoolsBridge();
+  let isRefreshing = false;
+  let queue = [];
+  const processQueue = (token) => {
+    queue.forEach((cb) => cb(token));
+    queue = [];
+  };
+  crossTab.listen((token) => {
+    config.setAccessToken?.(token);
+  });
+  const refresh = async () => {
+    if (!breaker.canExecute())
+      throw new Error("Circuit OPEN");
+    if (!await cooldown.canProceed())
+      throw new Error("Cooldown");
+    if (isRefreshing)
+      return new Promise((res) => queue.push(res));
+    isRefreshing = true;
+    try {
+      const token = await retryRequest(
+        () => config.refreshTokenFn(),
+        config.retry?.maxRetries ?? 0
+      );
+      breaker.onSuccess();
+      cooldown.activate();
+      config.setAccessToken?.(token);
+      crossTab.broadcast(token);
+      processQueue(token);
+      await detectAnomaly(config.anomaly);
+      devtools?.emit({ type: "refresh_success" });
+      return token;
+    } catch (e) {
+      breaker.onFailure();
+      cooldown.activate();
+      config.logout?.();
+      throw e;
+    } finally {
+      isRefreshing = false;
+    }
+  };
+  config.axiosInstance.interceptors.response.use(
+    (r) => r,
+    async (error) => {
+      if (error.response?.status === 401) {
+        const token = await refresh();
+        error.config.headers.Authorization = token;
+        return config.axiosInstance(error.config);
+      }
+      return Promise.reject(error);
+    }
+  );
+};
+export {
+  createAxiosRefresh
+};

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@gajay/axios-refresh-core",
+  "version": "1.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "axios": "^1"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "jest"
+  }
+}