@flexbe/sdk 0.2.28 → 0.2.30

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

@@ -7,12 +7,32 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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
+        }
+    }
+    getAuthHeaders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield 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();
@@ -27,12 +47,12 @@ export class ApiClient {
     }
     request(config) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             try {
-                yield 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 = Object.assign(Object.assign({}, (yield this.auth.getAuthHeaders())), config.headers);
+                const headers = Object.assign(Object.assign({ 'Content-Type': 'application/json' }, (yield this.getAuthHeaders())), config.headers);
                 const response = yield fetch(this.config.baseUrl + url, Object.assign(Object.assign({}, config), { headers, signal: controller.signal }));
                 clearTimeout(timeoutId);
                 if (!response.ok) {
@@ -44,23 +64,24 @@ export class ApiClient {
                     const errorData = yield 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
                             };
                     }
                 }
@@ -80,6 +101,9 @@ export class ApiClient {
                 };
             }
             catch (error) {
+                if (error instanceof UnauthorizedException) {
+                    (_b = (_a = this.config.hooks) === null || _a === void 0 ? void 0 : _a.onUnauthorized) === null || _b === void 0 ? void 0 : _b.call(_a);
+                }
                 if (error instanceof Error && error.name === 'AbortError') {
                     throw new TimeoutException('Request timeout');
                 }

package/dist/browser/client/client.js

@@ -21,12 +21,13 @@ export class FlexbeClient {
             }
             return undefined;
         };
-        this.config = {
-            baseUrl: (config === null || config === void 0 ? void 0 : config.baseUrl) || getEnvVar('FLEXBE_API_URL') || 'https://api.flexbe.com',
-            timeout: (config === null || config === void 0 ? void 0 : config.timeout) || 30000,
-            apiKey: (config === null || config === void 0 ? void 0 : config.apiKey) || getEnvVar('FLEXBE_API_KEY') || '',
-            authType: (config === null || config === void 0 ? void 0 : config.authType) || FlexbeAuthType.API_KEY,
+        const defaultConfig = {
+            baseUrl: getEnvVar('FLEXBE_API_URL') || 'https://api.flexbe.com',
+            timeout: 30000,
+            apiKey: getEnvVar('FLEXBE_API_KEY') || '',
+            authType: FlexbeAuthType.API_KEY,
         };
+        this.config = Object.assign(Object.assign({}, 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.');
         }

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

@@ -7,19 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { UnauthorizedException } from '../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
 export 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) {
@@ -27,85 +20,65 @@ export class TokenManager {
         }
         return TokenManager.instance;
     }
-    initializeFromStorage() {
-        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();
+    getToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            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;
             }
-        }
-        catch (error) {
-            console.error('Failed to parse stored token:', error);
-            this.clearToken();
-        }
+            yield this.retrieveToken();
+            const retrievedToken = this.getStoredToken();
+            return (_a = retrievedToken === null || retrievedToken === void 0 ? void 0 : retrievedToken.accessToken) !== null && _a !== void 0 ? _a : null;
+        });
     }
-    setupStorageListener() {
-        if (typeof window === 'undefined')
-            return;
-        window.addEventListener('storage', (event) => {
-            if (event.key !== TOKEN_STORAGE_KEY)
-                return;
-            if (!event.newValue) {
-                this.clearToken();
-                // void this.retrieveToken();
+    revokeToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = this.getStoredToken();
+            this.clearToken();
+            if (!token)
                 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();
-                }
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 30000);
+                yield 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 token from storage event:', error);
-                this.clearToken();
-                void this.retrieveToken();
+                console.error('Failed to revoke token:', error);
             }
         });
     }
-    getExpirationFromToken(token) {
+    getStoredToken() {
+        if (typeof window === 'undefined')
+            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
+            console.error('getStoredToken: Failed to parse stored token:', error);
+            return null;
         }
     }
-    getToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const token = this.token;
-            if (token && token.expiresAt && token.expiresAt > Date.now()) {
-                return token.accessToken;
-            }
-            yield this.retrieveToken();
-            return (_b = (_a = this.token) === null || _a === void 0 ? void 0 : _a.accessToken) !== null && _b !== void 0 ? _b : null;
-        });
-    }
     retrieveToken() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.tokenPromise) {
@@ -136,130 +109,44 @@ export class TokenManager {
                 clearTimeout(timeoutId);
                 if (!response.ok) {
                     const errorData = yield response.json().catch(() => ({ message: response.statusText }));
+                    if (response.status === 401) {
+                        throw new UnauthorizedException(errorData.message || response.statusText);
+                    }
                     throw new Error(errorData.message || response.statusText);
                 }
                 const data = yield 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, Object.assign({ 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));
+            localStorage.setItem(TOKEN_STORAGE_KEY, JSON.stringify(token));
         }
-        this.startRefreshInterval();
     }
-    clearToken() {
-        this.token = null;
-        this.clearRefreshTimers();
-        if (typeof window !== 'undefined') {
-            localStorage.removeItem(TOKEN_STORAGE_KEY);
+    getExpirationFromToken(token) {
+        try {
+            const [, payload] = token.split('.');
+            const decodedPayload = JSON.parse(atob(payload));
+            return decodedPayload.exp * 1000; // Convert to milliseconds
+        }
+        catch (error) {
+            console.error('getExpirationFromToken: Failed to parse token expiration:', error);
+            return Date.now() + (4 * 60 * 1000); // Default to 4 minutes if parsing fails
         }
     }
-    revokeToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const token = this.token;
-            this.clearToken();
-            if (!token)
-                return;
-            try {
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), 30000);
-                yield 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 revoke token:', error);
-                // Even if revocation fails, we still want to clear the local token
-            }
-        });
+    clearToken() {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        localStorage.removeItem(TOKEN_STORAGE_KEY);
     }
 }

package/dist/browser/types/index.js

@@ -4,44 +4,56 @@ export var FlexbeAuthType;
     FlexbeAuthType["BEARER"] = "bearer";
 })(FlexbeAuthType || (FlexbeAuthType = {}));
 export 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;
     }
 }
 export 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;
     }
 }
 export 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;
     }
 }
 export 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;
     }
 }
 export 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;
     }
 }
 export 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;
     }
 }

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

@@ -2,11 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiClient = void 0;
 const types_1 = require("../types");
-const auth_1 = require("./auth");
+const token_manager_1 = require("./token-manager");
 class ApiClient {
     constructor(config) {
         this.config = config;
-        this.auth = new auth_1.FlexbeAuth(config);
+        this.tokenManager = token_manager_1.TokenManager.getInstance();
+        if (this.config.authType === types_1.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 === types_1.FlexbeAuthType.API_KEY) {
+            headers['x-api-key'] = this.config.apiKey;
+        }
+        else if (this.config.authType === types_1.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();
@@ -21,12 +39,12 @@ 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, {
@@ -44,23 +62,24 @@ class ApiClient {
                 const errorData = await response.json().catch(() => defaultError);
                 switch (errorData.statusCode) {
                     case 400:
-                        throw new types_1.BadRequestException(errorData.message);
+                        throw new types_1.BadRequestException(errorData.message, errorData.error, errorData.errors);
                     case 401:
-                        throw new types_1.UnauthorizedException(errorData.message);
+                        throw new types_1.UnauthorizedException(errorData.message, errorData.error, errorData.errors);
                     case 403:
-                        throw new types_1.ForbiddenException(errorData.message);
+                        throw new types_1.ForbiddenException(errorData.message, errorData.error, errorData.errors);
                     case 404:
-                        throw new types_1.NotFoundException(errorData.message);
+                        throw new types_1.NotFoundException(errorData.message, errorData.error, errorData.errors);
                     case 500:
                     case 502:
                     case 503:
                     case 504:
-                        throw new types_1.ServerException(errorData.message, errorData.statusCode);
+                        throw new types_1.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
                         };
                 }
             }
@@ -80,6 +99,9 @@ class ApiClient {
             };
         }
         catch (error) {
+            if (error instanceof types_1.UnauthorizedException) {
+                this.config.hooks?.onUnauthorized?.();
+            }
             if (error instanceof Error && error.name === 'AbortError') {
                 throw new types_1.TimeoutException('Request timeout');
             }

package/dist/cjs/client/client.js

@@ -15,11 +15,15 @@ class FlexbeClient {
             }
             return undefined;
         };
+        const defaultConfig = {
+            baseUrl: getEnvVar('FLEXBE_API_URL') || 'https://api.flexbe.com',
+            timeout: 30000,
+            apiKey: getEnvVar('FLEXBE_API_KEY') || '',
+            authType: types_1.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 || types_1.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.');