@cemiar/auth-sdk 1.0.21 → 1.0.23

package/dist/browser/CemiarAuthClient.d.ts

@@ -5,9 +5,11 @@ export declare class CemiarAuthClient implements CemiarAuthClientInstance {
     private readonly tenantId;
     private readonly auds;
     private readonly redirectUrl?;
+    private readonly onAuthFailure?;
     private storage;
     private loginMethod;
-    private refreshPromise;
+    private isRefreshing;
+    private failedQueue;
     constructor(config: CemiarAuthClientConfig);
     getAccessToken(): string | null;
     setAccessToken(token: string | null): void;
@@ -21,8 +23,8 @@ export declare class CemiarAuthClient implements CemiarAuthClientInstance {
     createApiClient(options: CreateApiClientOptions): AxiosInstance;
     attachInterceptors(instance: AxiosInstance): AxiosInstance;
     private addAuthHeader;
+    private processQueue;
     private handleResponseError;
-    private queueTokenRefresh;
     private loadLoginMethodFromStorage;
     private persistLoginMethod;
     private getCurrentLoginMethod;

package/dist/browser/CemiarAuthClient.js

@@ -17,13 +17,15 @@ export class CemiarAuthClient {
     constructor(config) {
         var _a, _b;
         this.storage = createDefaultTokenStorage();
-        this.refreshPromise = null;
+        this.isRefreshing = false;
+        this.failedQueue = [];
         this.baseUrl = normalizeBaseUrl(config.baseUrl || "http://localhost:3000") + "/auth";
         this.tenantId = config.tenantId;
         this.auds = parseAuds(config.auds);
         this.redirectUrl =
             (_a = config.redirectUrl) !== null && _a !== void 0 ? _a : (isBrowser ? `${window.location.origin}/auth/microsoft/callback` : undefined);
         this.storage = (_b = config.storage) !== null && _b !== void 0 ? _b : createDefaultTokenStorage();
+        this.onAuthFailure = config.onAuthFailure;
         this.loginMethod = this.loadLoginMethodFromStorage();
     }
     getAccessToken() {
@@ -127,35 +129,55 @@ export class CemiarAuthClient {
         }
         return config;
     }
+    processQueue(error, token = null) {
+        this.failedQueue.forEach(request => {
+            if (error) {
+                request.reject(error);
+            }
+            else if (token) {
+                request.resolve(token);
+            }
+        });
+        this.failedQueue = [];
+    }
     async handleResponseError(error, instance) {
-        var _a;
+        var _a, _b;
         const status = (_a = error.response) === null || _a === void 0 ? void 0 : _a.status;
         const originalRequest = error.config;
         if (status !== 401 || !originalRequest || originalRequest._retry) {
             return Promise.reject(error);
         }
+        // If already refreshing, queue this request to wait for the token
+        if (this.isRefreshing) {
+            return new Promise((resolve, reject) => {
+                this.failedQueue.push({ resolve, reject });
+            }).then(token => {
+                if (originalRequest.headers) {
+                    originalRequest.headers.Authorization = `Bearer ${token}`;
+                }
+                return instance(originalRequest);
+            });
+        }
         originalRequest._retry = true;
+        this.isRefreshing = true;
         try {
-            const newToken = await this.queueTokenRefresh();
+            const { accessToken: newToken } = await this.refreshToken();
+            this.processQueue(null, newToken);
             if (originalRequest.headers) {
                 originalRequest.headers.Authorization = `Bearer ${newToken}`;
             }
-            return instance(originalRequest);
+            const response = await instance(originalRequest);
+            return response;
         }
         catch (refreshError) {
+            this.processQueue(refreshError, null);
             this.setAccessToken(null);
+            (_b = this.onAuthFailure) === null || _b === void 0 ? void 0 : _b.call(this);
             return Promise.reject(refreshError);
         }
-    }
-    async queueTokenRefresh() {
-        if (!this.refreshPromise) {
-            this.refreshPromise = this.refreshToken()
-                .then(tokens => tokens.accessToken)
-                .finally(() => {
-                this.refreshPromise = null;
-            });
+        finally {
+            this.isRefreshing = false;
         }
-        return this.refreshPromise;
     }
     loadLoginMethodFromStorage() {
         if (!isBrowser || !("localStorage" in globalThis)) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cemiar/auth-sdk",
-    "version": "1.0.21",
+    "version": "1.0.23",
     "description": "Cemiar Auth integration helpers for web apps and APIs.",
     "type": "module",
     "main": "dist/index.js",