@flexbe/sdk 0.1.2 → 0.1.3

package/dist/esm/client/token-manager.js

@@ -1,9 +1,14 @@
 const TOKEN_STORAGE_KEY = 'flexbe_jwt_token';
 const REFRESH_THRESHOLD = 0.8; // Refresh when 80% of token lifetime has passed
+const REFRESH_CHECK_INTERVAL = 30 * 1000; // Check every 30 seconds
+const MAX_REFRESH_DELAY = 10000; // Maximum random delay of 10 seconds
 export class TokenManager {
     constructor() {
         this.token = null;
         this.refreshInterval = null;
+        this.refreshTimeout = null;
+        this.tokenPromise = null;
+        this.debug = false;
         this.initializeFromStorage();
         this.setupStorageListener();
     }
@@ -14,59 +19,61 @@ export class TokenManager {
         return TokenManager.instance;
     }
     initializeFromStorage() {
-        if (typeof window !== 'undefined') {
-            const storedToken = localStorage.getItem(TOKEN_STORAGE_KEY);
-            if (storedToken) {
-                try {
-                    this.token = JSON.parse(storedToken);
-                    if (this.token.expiresAt > Date.now()) {
-                        console.log('Reusing stored token:', {
-                            expiresIn: `${Math.round((this.token.expiresAt - Date.now()) / 1000)} seconds`,
-                            expiresAt: new Date(this.token.expiresAt).toISOString(),
-                        });
-                        this.startRefreshInterval();
-                    }
-                    else {
-                        this.clearToken();
-                    }
-                }
-                catch (error) {
-                    console.error('Failed to parse stored token:', error);
-                    this.clearToken();
-                }
+        if (typeof window === 'undefined')
+            return;
+        const storedToken = localStorage.getItem(TOKEN_STORAGE_KEY);
+        if (!storedToken)
+            return;
+        try {
+            this.token = JSON.parse(storedToken);
+            if (this.token.expiresAt > Date.now()) {
+                this.logTokenStatus('Token loaded from storage');
+                this.startRefreshInterval();
+            }
+            else {
+                this.clearToken();
             }
         }
+        catch (error) {
+            console.error('Failed to parse stored token:', error);
+            this.clearToken();
+        }
     }
     setupStorageListener() {
-        if (typeof window !== 'undefined') {
-            window.addEventListener('storage', (event) => {
-                if (event.key === TOKEN_STORAGE_KEY) {
-                    if (event.newValue) {
-                        try {
-                            const newToken = JSON.parse(event.newValue);
-                            if (newToken.expiresAt > Date.now()) {
-                                this.token = newToken;
-                                console.log('Token updated from storage:', {
-                                    expiresIn: `${Math.round((newToken.expiresAt - Date.now()) / 1000)} seconds`,
-                                    expiresAt: new Date(newToken.expiresAt).toISOString(),
-                                });
-                                this.startRefreshInterval();
-                            }
-                            else {
-                                this.clearToken();
-                            }
-                        }
-                        catch (error) {
-                            console.error('Failed to parse token from storage event:', error);
-                            this.clearToken();
-                        }
-                    }
-                    else {
-                        this.clearToken();
-                    }
+        if (typeof window === 'undefined')
+            return;
+        window.addEventListener('storage', (event) => {
+            if (event.key !== TOKEN_STORAGE_KEY)
+                return;
+            if (!event.newValue) {
+                this.clearToken();
+                void this.retrieveToken();
+                return;
+            }
+            try {
+                const newToken = JSON.parse(event.newValue);
+                // Skip if the new token is exactly the same as current token
+                if (this.token &&
+                    this.token.accessToken === newToken.accessToken &&
+                    this.token.expiresAt === newToken.expiresAt) {
+                    return;
                 }
-            });
-        }
+                if (newToken.expiresAt > Date.now()) {
+                    this.token = newToken;
+                    this.logTokenStatus('Token updated from storage');
+                    this.startRefreshInterval();
+                }
+                else {
+                    this.clearToken();
+                    void this.retrieveToken();
+                }
+            }
+            catch (error) {
+                console.error('Failed to parse token from storage event:', error);
+                this.clearToken();
+                void this.retrieveToken();
+            }
+        });
     }
     getExpirationFromToken(token) {
         try {
@@ -79,32 +86,125 @@ export class TokenManager {
             return Date.now() + (4 * 60 * 1000); // Default to 4 minutes if parsing fails
         }
     }
+    async getToken() {
+        const token = this.token;
+        if (token && token.expiresAt && token.expiresAt > Date.now()) {
+            return token.accessToken;
+        }
+        await this.retrieveToken();
+        return this.token?.accessToken ?? null;
+    }
+    async retrieveToken() {
+        if (this.tokenPromise) {
+            await this.tokenPromise;
+            return;
+        }
+        this.tokenPromise = this.doRetrieveToken();
+        try {
+            await this.tokenPromise;
+        }
+        finally {
+            this.tokenPromise = null;
+        }
+    }
+    async doRetrieveToken() {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 30000);
+        try {
+            const response = await fetch('/oauth/token', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ grant_type: 'client_credentials' }),
+                credentials: 'include',
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({ message: response.statusText }));
+                throw new Error(errorData.message || response.statusText);
+            }
+            const data = await response.json();
+            this.setToken(data);
+        }
+        catch (error) {
+            console.error('Failed to retrieve token:', error);
+            this.clearToken();
+            throw error;
+        }
+    }
     startRefreshInterval() {
+        this.clearRefreshTimers();
+        if (!this.token)
+            return;
+        const tokenLifetime = this.token.expiresAt - Date.now();
+        const refreshThreshold = Math.round(tokenLifetime * REFRESH_THRESHOLD);
+        const timeUntilRefresh = refreshThreshold - (Math.random() * MAX_REFRESH_DELAY);
+        this.logTokenStatus('Starting refresh interval', {
+            tokenLifetime: `${Math.round(tokenLifetime / 1000)} seconds`,
+            refreshThreshold: `${Math.round(refreshThreshold / 1000)} seconds`,
+            timeUntilRefresh: `${Math.round(timeUntilRefresh / 1000)} seconds`,
+        });
+        this.scheduleRefresh(timeUntilRefresh);
+        this.refreshInterval = window.setInterval(() => {
+            if (!this.token)
+                return;
+            const timeUntilExpiry = this.token.expiresAt - Date.now();
+            if (timeUntilExpiry <= 0) {
+                this.logTokenStatus('Token expired');
+                this.clearToken();
+                void this.retrieveToken();
+                return;
+            }
+            const refreshThreshold = Math.round(timeUntilExpiry * REFRESH_THRESHOLD);
+            if (timeUntilExpiry <= refreshThreshold) {
+                this.logTokenStatus('Refreshing token', {
+                    timeUntilExpiry: `${Math.round(timeUntilExpiry / 1000)} seconds`,
+                    refreshThreshold: `${Math.round(refreshThreshold / 1000)} seconds`,
+                });
+                this.scheduleRefresh(refreshThreshold - (Math.random() * MAX_REFRESH_DELAY));
+            }
+        }, REFRESH_CHECK_INTERVAL);
+    }
+    scheduleRefresh(delay) {
+        if (this.refreshTimeout) {
+            window.clearTimeout(this.refreshTimeout);
+        }
+        this.refreshTimeout = window.setTimeout(() => {
+            const token = this.token;
+            if (token && token.expiresAt - Date.now() <= token.expiresAt * REFRESH_THRESHOLD) {
+                void this.retrieveToken();
+            }
+        }, delay);
+    }
+    clearRefreshTimers() {
         if (this.refreshInterval) {
             clearInterval(this.refreshInterval);
+            this.refreshInterval = null;
         }
-        if (this.token) {
-            const tokenLifetime = this.token.expiresAt - (this.token.expiresAt - 4 * 60 * 1000); // 4 minutes in milliseconds
-            const refreshTime = Math.round(tokenLifetime * REFRESH_THRESHOLD);
-            console.log('Setting up token refresh:', {
-                tokenLifetime: `${Math.round(tokenLifetime / 1000)} seconds`,
-                refreshIn: `${Math.round(refreshTime / 1000)} seconds`,
-                refreshAt: new Date(Date.now() + refreshTime).toISOString(),
-            });
-            this.refreshInterval = window.setInterval(() => {
-                this.clearToken();
-            }, refreshTime);
+        if (this.refreshTimeout) {
+            window.clearTimeout(this.refreshTimeout);
+            this.refreshTimeout = null;
         }
     }
+    logTokenStatus(message, additionalInfo = {}) {
+        if (!this.debug)
+            return;
+        const token = this.token;
+        if (!token)
+            return;
+        console.log(message, {
+            expiresIn: `${Math.round((token.expiresAt - Date.now()) / 1000)} seconds`,
+            expiresAt: new Date(token.expiresAt).toISOString(),
+            ...additionalInfo,
+        });
+    }
     setToken(tokenResponse) {
         const expiresAt = this.getExpirationFromToken(tokenResponse.accessToken);
         this.token = {
             accessToken: tokenResponse.accessToken,
             expiresAt,
         };
-        const expiresIn = Math.round((expiresAt - Date.now()) / 1000);
-        console.log('New access token obtained:', {
-            expiresIn: `${expiresIn} seconds`,
+        this.logTokenStatus('Token set', {
             expiresAt: new Date(expiresAt).toISOString(),
         });
         if (typeof window !== 'undefined') {
@@ -112,19 +212,9 @@ export class TokenManager {
         }
         this.startRefreshInterval();
     }
-    getToken() {
-        if (this.token && this.token.expiresAt > Date.now()) {
-            return this.token.accessToken;
-        }
-        this.clearToken();
-        return null;
-    }
     clearToken() {
         this.token = null;
-        if (this.refreshInterval) {
-            clearInterval(this.refreshInterval);
-            this.refreshInterval = null;
-        }
+        this.clearRefreshTimers();
         if (typeof window !== 'undefined') {
             localStorage.removeItem(TOKEN_STORAGE_KEY);
         }

package/dist/esm/types/index.js

@@ -1 +1,5 @@
-export {};
+export var FlexbeAuthType;
+(function (FlexbeAuthType) {
+    FlexbeAuthType["API_KEY"] = "apiKey";
+    FlexbeAuthType["BEARER"] = "bearer";
+})(FlexbeAuthType || (FlexbeAuthType = {}));

package/dist/types/client/auth.d.ts

@@ -3,10 +3,9 @@ export declare class FlexbeAuth {
     private readonly config;
     private readonly tokenManager;
     private initialized;
-    private initializing;
+    private initializationPromise;
     constructor(config: FlexbeConfig);
-    private initializeBearerAuth;
+    private initialize;
     ensureInitialized(): Promise<void>;
     getAuthHeaders(): Promise<Record<string, string>>;
-    isInitialized(): boolean;
 }

package/dist/types/client/token-manager.d.ts

@@ -3,13 +3,21 @@ export declare class TokenManager {
     private static instance;
     private token;
     private refreshInterval;
+    private refreshTimeout;
+    private tokenPromise;
+    private debug;
     private constructor();
     static getInstance(): TokenManager;
     private initializeFromStorage;
     private setupStorageListener;
     private getExpirationFromToken;
+    getToken(): Promise<string | null>;
+    private retrieveToken;
+    private doRetrieveToken;
     private startRefreshInterval;
+    private scheduleRefresh;
+    private clearRefreshTimers;
+    private logTokenStatus;
     setToken(tokenResponse: TokenResponse): void;
-    getToken(): string | null;
     clearToken(): void;
 }

package/dist/types/types/index.d.ts

@@ -1,3 +1,7 @@
+export declare enum FlexbeAuthType {
+    API_KEY = "apiKey",
+    BEARER = "bearer"
+}
 export interface FlexbeConfig {
     apiKey?: string;
     baseUrl?: string;
@@ -21,7 +25,6 @@ export interface FlexbeError {
     status?: number;
     details?: unknown;
 }
-export type FlexbeAuthType = 'apiKey' | 'bearer';
 export interface JwtToken {
     accessToken: string;
     expiresAt: number;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flexbe/sdk",
-    "version": "0.1.2",
+    "version": "0.1.3",
     "description": "TypeScript SDK for Flexbe API",
     "main": "dist/cjs/index.js",
     "module": "dist/esm/index.js",