@flexbe/sdk 0.2.28 → 0.2.30

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

@@ -1,19 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenManager = void 0;
+const types_1 = require("../types");
 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
+const TOKEN_REFRESH_THRESHOLD = 5 * 60 * 1000; // update token 5 minutes before expiration
 class TokenManager {
     constructor() {
-        this.token = null;
-        this.refreshInterval = null;
-        this.refreshTimeout = null;
         this.tokenPromise = null;
-        this.debug = false;
-        this.initializeFromStorage();
-        this.setupStorageListener();
     }
     static getInstance() {
         if (!TokenManager.instance) {
@@ -21,81 +14,59 @@ class TokenManager {
         }
         return TokenManager.instance;
     }
-    initializeFromStorage() {
-        if (typeof window === 'undefined')
-            return;
-        const storedToken = localStorage.getItem(TOKEN_STORAGE_KEY);
-        if (!storedToken)
+    async getToken() {
+        const token = this.getStoredToken();
+        if (token && token.expiresAt > Date.now()) {
+            // TODO check if token expire less that 1 minute
+            // if so, retrieve a new token
+            if (token.expiresAt - Date.now() < TOKEN_REFRESH_THRESHOLD) {
+                void this.retrieveToken();
+            }
+            return token.accessToken;
+        }
+        await this.retrieveToken();
+        const retrievedToken = this.getStoredToken();
+        return retrievedToken?.accessToken ?? null;
+    }
+    async revokeToken() {
+        const token = this.getStoredToken();
+        this.clearToken();
+        if (!token)
             return;
         try {
-            this.token = JSON.parse(storedToken);
-            if (this.token.expiresAt > Date.now()) {
-                this.logTokenStatus('Token loaded from storage');
-                this.startRefreshInterval();
-            }
-            else {
-                this.clearToken();
-            }
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 30000);
+            await fetch('/oauth/revoke', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${token.accessToken}`
+                },
+                body: JSON.stringify({ token: token.accessToken }),
+                credentials: 'include',
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
         }
         catch (error) {
-            console.error('Failed to parse stored token:', error);
-            this.clearToken();
+            console.error('Failed to revoke token:', error);
         }
     }
-    setupStorageListener() {
+    getStoredToken() {
         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) {
+            return null;
+        const storedToken = localStorage.getItem(TOKEN_STORAGE_KEY);
+        if (!storedToken) {
+            return null;
+        }
         try {
-            const [, payload] = token.split('.');
-            const decodedPayload = JSON.parse(atob(payload));
-            return decodedPayload.exp * 1000; // Convert to milliseconds
+            const token = JSON.parse(storedToken);
+            return token;
         }
         catch (error) {
-            console.error('Failed to parse token expiration:', error);
-            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;
+            console.error('getStoredToken: Failed to parse stored token:', error);
+            return null;
         }
-        await this.retrieveToken();
-        return this.token?.accessToken ?? null;
     }
     async retrieveToken() {
         if (this.tokenPromise) {
@@ -124,132 +95,44 @@ class TokenManager {
             clearTimeout(timeoutId);
             if (!response.ok) {
                 const errorData = await response.json().catch(() => ({ message: response.statusText }));
+                if (response.status === 401) {
+                    throw new types_1.UnauthorizedException(errorData.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();
-            // Schedule a retry after REFRESH_CHECK_INTERVAL
-            setTimeout(() => {
-                void this.retrieveToken();
-            }, REFRESH_CHECK_INTERVAL);
             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.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 = {
+        const token = {
             accessToken: tokenResponse.accessToken,
             expiresAt,
         };
-        this.logTokenStatus('Token set', {
-            expiresAt: new Date(expiresAt).toISOString(),
-        });
-        if (typeof window !== 'undefined') {
-            localStorage.setItem(TOKEN_STORAGE_KEY, JSON.stringify(this.token));
-        }
-        this.startRefreshInterval();
-    }
-    clearToken() {
-        this.token = null;
-        this.clearRefreshTimers();
         if (typeof window !== 'undefined') {
-            localStorage.removeItem(TOKEN_STORAGE_KEY);
+            localStorage.setItem(TOKEN_STORAGE_KEY, JSON.stringify(token));
         }
     }
-    async revokeToken() {
-        const token = this.token;
-        this.clearToken();
-        if (!token)
-            return;
+    getExpirationFromToken(token) {
         try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), 30000);
-            await fetch('/oauth/revoke', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${token.accessToken}`
-                },
-                body: JSON.stringify({ token: token.accessToken }),
-                credentials: 'include',
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
+            const [, payload] = token.split('.');
+            const decodedPayload = JSON.parse(atob(payload));
+            return decodedPayload.exp * 1000; // Convert to milliseconds
         }
         catch (error) {
-            console.error('Failed to revoke token:', error);
-            // Even if revocation fails, we still want to clear the local token
+            console.error('getExpirationFromToken: Failed to parse token expiration:', error);
+            return Date.now() + (4 * 60 * 1000); // Default to 4 minutes if parsing fails
+        }
+    }
+    clearToken() {
+        if (typeof window === 'undefined') {
+            return;
         }
+        localStorage.removeItem(TOKEN_STORAGE_KEY);
     }
 }
 exports.TokenManager = TokenManager;

package/dist/cjs/types/index.js

@@ -7,50 +7,62 @@ var FlexbeAuthType;
     FlexbeAuthType["BEARER"] = "bearer";
 })(FlexbeAuthType || (exports.FlexbeAuthType = FlexbeAuthType = {}));
 class NotFoundException extends Error {
-    constructor(message) {
+    constructor(message, error, errors) {
         super(Array.isArray(message) ? message.join(', ') : message);
         this.statusCode = 404;
         this.name = 'NotFoundException';
+        this.error = error || 'not_found';
+        this.errors = errors;
     }
 }
 exports.NotFoundException = NotFoundException;
 class ForbiddenException extends Error {
-    constructor(message) {
+    constructor(message, error, errors) {
         super(Array.isArray(message) ? message.join(', ') : message);
         this.statusCode = 403;
         this.name = 'ForbiddenException';
+        this.error = error || 'forbidden';
+        this.errors = errors;
     }
 }
 exports.ForbiddenException = ForbiddenException;
 class BadRequestException extends Error {
-    constructor(message) {
+    constructor(message, error, errors) {
         super(Array.isArray(message) ? message.join(', ') : message);
         this.statusCode = 400;
         this.name = 'BadRequestException';
+        this.error = error || 'bad_request';
+        this.errors = errors;
     }
 }
 exports.BadRequestException = BadRequestException;
 class UnauthorizedException extends Error {
-    constructor(message) {
+    constructor(message, error, errors) {
         super(Array.isArray(message) ? message.join(', ') : message);
         this.statusCode = 401;
         this.name = 'UnauthorizedException';
+        this.error = error || 'unauthorized';
+        this.errors = errors;
     }
 }
 exports.UnauthorizedException = UnauthorizedException;
 class ServerException extends Error {
-    constructor(message, statusCode = 500) {
+    constructor(message, error, statusCode = 500, errors) {
         super(Array.isArray(message) ? message.join(', ') : message);
         this.name = 'ServerException';
+        this.error = error || 'server_error';
         this.statusCode = statusCode;
+        this.errors = errors;
     }
 }
 exports.ServerException = ServerException;
 class TimeoutException extends Error {
-    constructor(message) {
+    constructor(message, error, errors) {
         super(Array.isArray(message) ? message.join(', ') : message);
         this.statusCode = 408;
         this.name = 'TimeoutException';
+        this.error = error || 'timeout';
+        this.errors = errors;
     }
 }
 exports.TimeoutException = TimeoutException;

package/dist/esm/client/api-client.js

@@ -1,9 +1,27 @@
-import { NotFoundException, ForbiddenException, BadRequestException, UnauthorizedException, ServerException, TimeoutException } from '../types';
-import { FlexbeAuth } from './auth';
+import { NotFoundException, ForbiddenException, BadRequestException, UnauthorizedException, ServerException, TimeoutException, FlexbeAuthType } from '../types';
+import { TokenManager } from './token-manager';
 export class ApiClient {
     constructor(config) {
         this.config = config;
-        this.auth = new FlexbeAuth(config);
+        this.tokenManager = TokenManager.getInstance();
+        if (this.config.authType === FlexbeAuthType.BEARER) {
+            // Start initialization but don't wait for it
+            void this.tokenManager.getToken(); // just warm up the token manager before any request
+        }
+    }
+    async getAuthHeaders() {
+        const headers = {};
+        if (this.config.authType === FlexbeAuthType.API_KEY) {
+            headers['x-api-key'] = this.config.apiKey;
+        }
+        else if (this.config.authType === FlexbeAuthType.BEARER) {
+            const token = await this.tokenManager.getToken();
+            if (!token) {
+                throw new Error('No valid bearer token available');
+            }
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        return headers;
     }
     buildUrl(path, params) {
         const searchParams = new URLSearchParams();
@@ -18,12 +36,12 @@ export class ApiClient {
     }
     async request(config) {
         try {
-            await this.auth.ensureInitialized();
             const controller = new AbortController();
             const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
             const url = this.buildUrl(config.url, config.params);
             const headers = {
-                ...(await this.auth.getAuthHeaders()),
+                'Content-Type': 'application/json',
+                ...(await this.getAuthHeaders()),
                 ...config.headers,
             };
             const response = await fetch(this.config.baseUrl + url, {
@@ -41,23 +59,24 @@ export class ApiClient {
                 const errorData = await response.json().catch(() => defaultError);
                 switch (errorData.statusCode) {
                     case 400:
-                        throw new BadRequestException(errorData.message);
+                        throw new BadRequestException(errorData.message, errorData.error, errorData.errors);
                     case 401:
-                        throw new UnauthorizedException(errorData.message);
+                        throw new UnauthorizedException(errorData.message, errorData.error, errorData.errors);
                     case 403:
-                        throw new ForbiddenException(errorData.message);
+                        throw new ForbiddenException(errorData.message, errorData.error, errorData.errors);
                     case 404:
-                        throw new NotFoundException(errorData.message);
+                        throw new NotFoundException(errorData.message, errorData.error, errorData.errors);
                     case 500:
                     case 502:
                     case 503:
                     case 504:
-                        throw new ServerException(errorData.message, errorData.statusCode);
+                        throw new ServerException(errorData.message, errorData.error, errorData.statusCode, errorData.errors);
                     default:
                         throw {
                             message: errorData.message,
                             error: errorData.error,
-                            statusCode: errorData.statusCode
+                            statusCode: errorData.statusCode,
+                            errors: errorData.errors
                         };
                 }
             }
@@ -77,6 +96,9 @@ export class ApiClient {
             };
         }
         catch (error) {
+            if (error instanceof UnauthorizedException) {
+                this.config.hooks?.onUnauthorized?.();
+            }
             if (error instanceof Error && error.name === 'AbortError') {
                 throw new TimeoutException('Request timeout');
             }

package/dist/esm/client/client.js

@@ -12,11 +12,15 @@ export class FlexbeClient {
             }
             return undefined;
         };
+        const defaultConfig = {
+            baseUrl: getEnvVar('FLEXBE_API_URL') || 'https://api.flexbe.com',
+            timeout: 30000,
+            apiKey: getEnvVar('FLEXBE_API_KEY') || '',
+            authType: FlexbeAuthType.API_KEY,
+        };
         this.config = {
-            baseUrl: config?.baseUrl || getEnvVar('FLEXBE_API_URL') || 'https://api.flexbe.com',
-            timeout: config?.timeout || 30000,
-            apiKey: config?.apiKey || getEnvVar('FLEXBE_API_KEY') || '',
-            authType: config?.authType || FlexbeAuthType.API_KEY,
+            ...defaultConfig,
+            ...config,
         };
         if (this.config.authType === 'apiKey' && !this.config.apiKey) {
             throw new Error('API key is required when using apiKey authentication. Please provide it either through config or FLEXBE_API_KEY environment variable.');