@cemiar/auth-sdk 1.0.20 → 1.0.22

package/dist/browser/CemiarAuthClient.d.ts

@@ -5,12 +5,11 @@ export declare class CemiarAuthClient implements CemiarAuthClientInstance {
     private readonly tenantId;
     private readonly auds;
     private readonly redirectUrl?;
-    private storage;
-    private readonly onTokenChange?;
     private readonly onAuthFailure?;
-    private readonly logoutRedirectUrl?;
+    private storage;
     private loginMethod;
-    private refreshPromise;
+    private isRefreshing;
+    private failedQueue;
     constructor(config: CemiarAuthClientConfig);
     getAccessToken(): string | null;
     setAccessToken(token: string | null): void;
@@ -24,9 +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 handleAuthFailure;
     private loadLoginMethodFromStorage;
     private persistLoginMethod;
     private getCurrentLoginMethod;

package/dist/browser/CemiarAuthClient.js

@@ -15,31 +15,27 @@ function extractAccessToken(data) {
 }
 export class CemiarAuthClient {
     constructor(config) {
-        var _a, _b, _c;
+        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.onTokenChange = config.onTokenChange;
+        this.storage = (_b = config.storage) !== null && _b !== void 0 ? _b : createDefaultTokenStorage();
         this.onAuthFailure = config.onAuthFailure;
-        this.logoutRedirectUrl =
-            (_b = config.logoutRedirectUrl) !== null && _b !== void 0 ? _b : (isBrowser ? `${window.location.origin}/login` : undefined);
-        this.storage = (_c = config.storage) !== null && _c !== void 0 ? _c : createDefaultTokenStorage();
         this.loginMethod = this.loadLoginMethodFromStorage();
     }
     getAccessToken() {
         return this.storage.getToken();
     }
     setAccessToken(token) {
-        var _a;
         this.storage.setToken(token);
         if (token === null) {
             this.persistLoginMethod(null);
         }
-        (_a = this.onTokenChange) === null || _a === void 0 ? void 0 : _a.call(this, token);
     }
     async authPost(path, body, withCredentials = true) {
         const url = `${this.baseUrl}${path}`;
@@ -133,40 +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.handleAuthFailure();
+            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;
-    }
-    handleAuthFailure() {
-        var _a;
-        this.setAccessToken(null);
-        (_a = this.onAuthFailure) === null || _a === void 0 ? void 0 : _a.call(this);
     }
     loadLoginMethodFromStorage() {
         if (!isBrowser || !("localStorage" in globalThis)) {

package/dist/shared/Types.d.ts

@@ -17,7 +17,6 @@ export interface CemiarAuthClientConfig {
     storage?: TokenStorage;
     onTokenChange?: (token: string | null) => void;
     onAuthFailure?: () => void;
-    logoutRedirectUrl?: string;
 }
 export interface AuthTokens {
     accessToken: string;

package/package.json

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