@flexbe/sdk 0.1.2 → 0.1.4

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

@@ -72,15 +72,15 @@ export class ApiClient {
         });
     }
     get(url, config) {
-        return this.request(Object.assign(Object.assign({}, config), { method: 'GET', url }));
+        return this.request(Object.assign(Object.assign({}, config), { url, method: 'GET' }));
     }
     post(url, data, config) {
-        return this.request(Object.assign(Object.assign({}, config), { method: 'POST', url, body: JSON.stringify(data) }));
+        return this.request(Object.assign(Object.assign({}, config), { url, method: 'POST', body: JSON.stringify(data) }));
     }
     put(url, data, config) {
-        return this.request(Object.assign(Object.assign({}, config), { method: 'PUT', url, body: JSON.stringify(data) }));
+        return this.request(Object.assign(Object.assign({}, config), { url, method: 'PUT', body: JSON.stringify(data) }));
     }
     delete(url, config) {
-        return this.request(Object.assign(Object.assign({}, config), { method: 'DELETE', url }));
+        return this.request(Object.assign(Object.assign({}, config), { url, method: 'DELETE' }));
     }
 }

package/dist/browser/client/auth.js

@@ -7,81 +7,49 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { FlexbeAuthType } from '../types';
 import { TokenManager } from './token-manager';
 export class FlexbeAuth {
     constructor(config) {
         this.initialized = false;
-        this.initializing = false;
+        this.initializationPromise = null;
         this.config = config;
         this.tokenManager = TokenManager.getInstance();
-        if (this.config.authType === 'bearer') {
-            // Check if we have a valid token in storage
-            const existingToken = this.tokenManager.getToken();
-            if (existingToken) {
-                this.initialized = true;
-            }
-            // Don't start initialization here, let ensureInitialized handle it
+        if (this.config.authType === FlexbeAuthType.BEARER) {
+            // Start initialization but don't wait for it
+            this.initializationPromise = this.initialize();
         }
         else {
             this.initialized = true;
         }
     }
-    initializeBearerAuth() {
+    initialize() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.initializing) {
-                // Wait for the ongoing initialization to complete
-                while (this.initializing) {
-                    yield new Promise(resolve => setTimeout(resolve, 100));
-                }
-                return;
-            }
             try {
-                this.initializing = true;
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-                const response = yield 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 defaultError = { message: response.statusText };
-                    const errorData = yield response.json().catch(() => defaultError);
-                    const error = {
-                        message: errorData.message || response.statusText,
-                        code: errorData.code,
-                        status: response.status,
-                        details: errorData.details,
-                    };
-                    throw error;
-                }
-                const data = yield response.json();
-                this.tokenManager.setToken(data);
-                this.initialized = true;
+                const token = yield this.tokenManager.getToken();
+                this.initialized = !!token;
             }
             catch (error) {
-                console.error('Failed to initialize bearer authentication:', error);
-                this.initialized = false; // Reset initialized state on error
-                throw error;
+                console.error('Failed to initialize auth:', error);
+                this.initialized = false;
             }
             finally {
-                this.initializing = false;
+                this.initializationPromise = null;
             }
         });
     }
     ensureInitialized() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.config.authType !== 'bearer' || this.initialized) {
+            if (this.config.authType !== FlexbeAuthType.BEARER || this.initialized) {
                 return;
             }
-            yield this.initializeBearerAuth();
+            // If initialization is in progress, wait for it
+            if (this.initializationPromise) {
+                yield this.initializationPromise;
+                return;
+            }
+            // If not initialized and no initialization in progress, start one
+            yield this.initialize();
         });
     }
     getAuthHeaders() {
@@ -90,29 +58,17 @@ export class FlexbeAuth {
             const headers = {
                 'Content-Type': 'application/json',
             };
-            if (this.config.authType === 'apiKey') {
+            if (this.config.authType === FlexbeAuthType.API_KEY) {
                 headers['x-api-key'] = this.config.apiKey;
             }
-            else if (this.config.authType === 'bearer') {
-                const token = this.tokenManager.getToken();
+            else if (this.config.authType === FlexbeAuthType.BEARER) {
+                const token = yield this.tokenManager.getToken();
                 if (!token) {
-                    // If no token is available, try to initialize again
-                    this.initialized = false;
-                    yield this.ensureInitialized();
-                    const newToken = this.tokenManager.getToken();
-                    if (!newToken) {
-                        throw new Error('No valid bearer token available');
-                    }
-                    headers['Authorization'] = `Bearer ${newToken}`;
-                }
-                else {
-                    headers['Authorization'] = `Bearer ${token}`;
+                    throw new Error('No valid bearer token available');
                 }
+                headers['Authorization'] = `Bearer ${token}`;
             }
             return headers;
         });
     }
-    isInitialized() {
-        return this.initialized;
-    }
 }

package/dist/browser/client/client.js

@@ -1,3 +1,4 @@
+import { FlexbeAuthType } from '../types';
 import { Pages } from './pages';
 import { ApiClient } from './api-client';
 export class FlexbeClient {
@@ -13,7 +14,7 @@ export class FlexbeClient {
             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') || '',
             siteId: (config === null || config === void 0 ? void 0 : config.siteId) || getEnvVar('FLEXBE_SITE_ID'),
-            authType: (config === null || config === void 0 ? void 0 : config.authType) || 'apiKey',
+            authType: (config === null || config === void 0 ? void 0 : config.authType) || FlexbeAuthType.API_KEY,
         };
         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/pages.js

@@ -29,4 +29,22 @@ export class Pages {
             return response.data;
         });
     }
+    /**
+     * Get list of folders for a site
+     */
+    getFolders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.api.get('/sites/:siteId:/pages-folders');
+            return response.data;
+        });
+    }
+    /**
+     * Get a single folder by ID
+     */
+    getFolder(folderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.api.get(`/sites/:siteId:/pages-folders/${folderId}`);
+            return response.data;
+        });
+    }
 }

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

@@ -1,9 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 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 +28,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 +95,132 @@ export class TokenManager {
             return Date.now() + (4 * 60 * 1000); // Default to 4 minutes if parsing fails
         }
     }
+    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) {
+                yield this.tokenPromise;
+                return;
+            }
+            this.tokenPromise = this.doRetrieveToken();
+            try {
+                yield this.tokenPromise;
+            }
+            finally {
+                this.tokenPromise = null;
+            }
+        });
+    }
+    doRetrieveToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 30000);
+            try {
+                const response = yield 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 = yield response.json().catch(() => ({ 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.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, 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 = {
             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 +228,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/browser/types/index.js

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

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

@@ -71,16 +71,16 @@ class ApiClient {
         }
     }
     get(url, config) {
-        return this.request({ ...config, method: 'GET', url });
+        return this.request({ ...config, url, method: 'GET' });
     }
     post(url, data, config) {
-        return this.request({ ...config, method: 'POST', url, body: JSON.stringify(data) });
+        return this.request({ ...config, url, method: 'POST', body: JSON.stringify(data) });
     }
     put(url, data, config) {
-        return this.request({ ...config, method: 'PUT', url, body: JSON.stringify(data) });
+        return this.request({ ...config, url, method: 'PUT', body: JSON.stringify(data) });
     }
     delete(url, config) {
-        return this.request({ ...config, method: 'DELETE', url });
+        return this.request({ ...config, url, method: 'DELETE' });
     }
 }
 exports.ApiClient = ApiClient;

package/dist/cjs/client/auth.js

@@ -1,107 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlexbeAuth = void 0;
+const types_1 = require("../types");
 const token_manager_1 = require("./token-manager");
 class FlexbeAuth {
     constructor(config) {
         this.initialized = false;
-        this.initializing = false;
+        this.initializationPromise = null;
         this.config = config;
         this.tokenManager = token_manager_1.TokenManager.getInstance();
-        if (this.config.authType === 'bearer') {
-            // Check if we have a valid token in storage
-            const existingToken = this.tokenManager.getToken();
-            if (existingToken) {
-                this.initialized = true;
-            }
-            // Don't start initialization here, let ensureInitialized handle it
+        if (this.config.authType === types_1.FlexbeAuthType.BEARER) {
+            // Start initialization but don't wait for it
+            this.initializationPromise = this.initialize();
         }
         else {
             this.initialized = true;
         }
     }
-    async initializeBearerAuth() {
-        if (this.initializing) {
-            // Wait for the ongoing initialization to complete
-            while (this.initializing) {
-                await new Promise(resolve => setTimeout(resolve, 100));
-            }
-            return;
-        }
+    async initialize() {
         try {
-            this.initializing = true;
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-            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 defaultError = { message: response.statusText };
-                const errorData = await response.json().catch(() => defaultError);
-                const error = {
-                    message: errorData.message || response.statusText,
-                    code: errorData.code,
-                    status: response.status,
-                    details: errorData.details,
-                };
-                throw error;
-            }
-            const data = await response.json();
-            this.tokenManager.setToken(data);
-            this.initialized = true;
+            const token = await this.tokenManager.getToken();
+            this.initialized = !!token;
         }
         catch (error) {
-            console.error('Failed to initialize bearer authentication:', error);
-            this.initialized = false; // Reset initialized state on error
-            throw error;
+            console.error('Failed to initialize auth:', error);
+            this.initialized = false;
         }
         finally {
-            this.initializing = false;
+            this.initializationPromise = null;
         }
     }
     async ensureInitialized() {
-        if (this.config.authType !== 'bearer' || this.initialized) {
+        if (this.config.authType !== types_1.FlexbeAuthType.BEARER || this.initialized) {
+            return;
+        }
+        // If initialization is in progress, wait for it
+        if (this.initializationPromise) {
+            await this.initializationPromise;
             return;
         }
-        await this.initializeBearerAuth();
+        // If not initialized and no initialization in progress, start one
+        await this.initialize();
     }
     async getAuthHeaders() {
         await this.ensureInitialized();
         const headers = {
             'Content-Type': 'application/json',
         };
-        if (this.config.authType === 'apiKey') {
+        if (this.config.authType === types_1.FlexbeAuthType.API_KEY) {
             headers['x-api-key'] = this.config.apiKey;
         }
-        else if (this.config.authType === 'bearer') {
-            const token = this.tokenManager.getToken();
+        else if (this.config.authType === types_1.FlexbeAuthType.BEARER) {
+            const token = await this.tokenManager.getToken();
             if (!token) {
-                // If no token is available, try to initialize again
-                this.initialized = false;
-                await this.ensureInitialized();
-                const newToken = this.tokenManager.getToken();
-                if (!newToken) {
-                    throw new Error('No valid bearer token available');
-                }
-                headers['Authorization'] = `Bearer ${newToken}`;
-            }
-            else {
-                headers['Authorization'] = `Bearer ${token}`;
+                throw new Error('No valid bearer token available');
             }
+            headers['Authorization'] = `Bearer ${token}`;
         }
         return headers;
     }
-    isInitialized() {
-        return this.initialized;
-    }
 }
 exports.FlexbeAuth = FlexbeAuth;