@flexbe/sdk 0.1.1 → 0.1.3

package/dist/cjs/client/auth.js

@@ -0,0 +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.initializationPromise = null;
+        this.config = config;
+        this.tokenManager = token_manager_1.TokenManager.getInstance();
+        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 initialize() {
+        try {
+            const token = await this.tokenManager.getToken();
+            this.initialized = !!token;
+        }
+        catch (error) {
+            console.error('Failed to initialize auth:', error);
+            this.initialized = false;
+        }
+        finally {
+            this.initializationPromise = null;
+        }
+    }
+    async ensureInitialized() {
+        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;
+        }
+        // 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 === 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;
+    }
+}
+exports.FlexbeAuth = FlexbeAuth;

package/dist/cjs/client/client.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlexbeClient = void 0;
+const types_1 = require("../types");
 const pages_1 = require("./pages");
+const api_client_1 = require("./api-client");
 class FlexbeClient {
     constructor(config) {
         const getEnvVar = (key) => {
@@ -15,96 +17,13 @@ class FlexbeClient {
             timeout: config?.timeout || 30000,
             apiKey: config?.apiKey || getEnvVar('FLEXBE_API_KEY') || '',
             siteId: config?.siteId || getEnvVar('FLEXBE_SITE_ID'),
+            authType: config?.authType || types_1.FlexbeAuthType.API_KEY,
         };
-        if (!this.config.apiKey) {
-            throw new Error('API key is required. Please provide it either through config or FLEXBE_API_KEY environment variable.');
+        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.');
         }
-        this.pages = new pages_1.Pages(this);
-    }
-    buildUrl(path, params) {
-        const searchParams = new URLSearchParams();
-        if (params) {
-            Object.entries(params).forEach(([key, value]) => {
-                if (value !== undefined && value !== null) {
-                    searchParams.append(key, String(value));
-                }
-            });
-        }
-        return `${path}${searchParams.toString() ? `?${searchParams.toString()}` : ''}`;
-    }
-    async request(config) {
-        try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-            const url = this.buildUrl(config.url, config.params);
-            const response = await fetch(this.config.baseUrl + url, {
-                ...config,
-                headers: {
-                    'Authorization': `Bearer ${this.config.apiKey}`,
-                    'Content-Type': 'application/json',
-                    ...config.headers,
-                },
-                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();
-            return {
-                data,
-                status: response.status,
-                statusText: response.statusText,
-            };
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === 'AbortError') {
-                const timeoutError = {
-                    message: 'Request timeout',
-                    status: 408,
-                };
-                throw timeoutError;
-            }
-            throw error;
-        }
-    }
-    get(url, config) {
-        return this.request({ ...config, method: 'GET', url });
-    }
-    post(url, data, config) {
-        return this.request({ ...config, method: 'POST', url, body: JSON.stringify(data) });
-    }
-    put(url, data, config) {
-        return this.request({ ...config, method: 'PUT', url, body: JSON.stringify(data) });
-    }
-    delete(url, config) {
-        return this.request({ ...config, method: 'DELETE', url });
-    }
-    getSiteUrl(path) {
-        if (!this.config.siteId) {
-            return path;
-        }
-        return `/sites/${this.config.siteId}${path}`;
-    }
-    sitesGet(path, config) {
-        return this.get(this.getSiteUrl(path), config);
-    }
-    sitesPost(path, data, config) {
-        return this.post(this.getSiteUrl(path), data, config);
-    }
-    sitesPut(path, data, config) {
-        return this.put(this.getSiteUrl(path), data, config);
-    }
-    sitesDelete(path, config) {
-        return this.delete(this.getSiteUrl(path), config);
+        this.api = new api_client_1.ApiClient(this.config);
+        this.pages = new pages_1.Pages(this.api);
     }
 }
 exports.FlexbeClient = FlexbeClient;

package/dist/cjs/client/pages.js

@@ -2,21 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pages = void 0;
 class Pages {
-    constructor(client) {
-        this.client = client;
+    constructor(api) {
+        this.api = api;
     }
     /**
      * Get list of pages for a site
      */
     async getPages(params) {
-        const response = await this.client.sitesGet('/pages', { params });
+        const response = await this.api.get('/sites/:siteId:/pages', { params });
         return response.data;
     }
     /**
      * Get a single page by ID
      */
     async getPage(pageId) {
-        const response = await this.client.sitesGet(`/pages/${pageId}`);
+        const response = await this.api.get(`/sites/:siteId:/pages/${pageId}`);
         return response.data;
     }
 }

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

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenManager = void 0;
+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
+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) {
+            TokenManager.instance = new 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();
+            }
+        }
+        catch (error) {
+            console.error('Failed to parse stored token:', error);
+            this.clearToken();
+        }
+    }
+    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();
+                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 {
+            const [, payload] = token.split('.');
+            const decodedPayload = JSON.parse(atob(payload));
+            return decodedPayload.exp * 1000; // Convert to milliseconds
+        }
+        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;
+        }
+        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.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,
+        };
+        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);
+        }
+    }
+}
+exports.TokenManager = TokenManager;

package/dist/cjs/types/index.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexbeAuthType = void 0;
+var FlexbeAuthType;
+(function (FlexbeAuthType) {
+    FlexbeAuthType["API_KEY"] = "apiKey";
+    FlexbeAuthType["BEARER"] = "bearer";
+})(FlexbeAuthType || (exports.FlexbeAuthType = FlexbeAuthType = {}));

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

@@ -0,0 +1,82 @@
+import { FlexbeAuth } from './auth';
+export class ApiClient {
+    constructor(config) {
+        this.config = config;
+        this.auth = new FlexbeAuth(config);
+    }
+    replaceSiteId(url) {
+        if (!this.config.siteId) {
+            return url;
+        }
+        return url.replace(/:siteId:/g, this.config.siteId);
+    }
+    buildUrl(path, params) {
+        const processedPath = this.replaceSiteId(path);
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    searchParams.append(key, String(value));
+                }
+            });
+        }
+        return `${processedPath}${searchParams.toString() ? `?${searchParams.toString()}` : ''}`;
+    }
+    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()),
+                ...config.headers,
+            };
+            const response = await fetch(this.config.baseUrl + url, {
+                ...config,
+                headers,
+                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();
+            return {
+                data,
+                status: response.status,
+                statusText: response.statusText,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                const timeoutError = {
+                    message: 'Request timeout',
+                    status: 408,
+                };
+                throw timeoutError;
+            }
+            throw error;
+        }
+    }
+    get(url, config) {
+        return this.request({ ...config, method: 'GET', url });
+    }
+    post(url, data, config) {
+        return this.request({ ...config, method: 'POST', url, body: JSON.stringify(data) });
+    }
+    put(url, data, config) {
+        return this.request({ ...config, method: 'PUT', url, body: JSON.stringify(data) });
+    }
+    delete(url, config) {
+        return this.request({ ...config, method: 'DELETE', url });
+    }
+}

package/dist/esm/client/auth.js

@@ -0,0 +1,59 @@
+import { FlexbeAuthType } from '../types';
+import { TokenManager } from './token-manager';
+export class FlexbeAuth {
+    constructor(config) {
+        this.initialized = false;
+        this.initializationPromise = null;
+        this.config = config;
+        this.tokenManager = TokenManager.getInstance();
+        if (this.config.authType === FlexbeAuthType.BEARER) {
+            // Start initialization but don't wait for it
+            this.initializationPromise = this.initialize();
+        }
+        else {
+            this.initialized = true;
+        }
+    }
+    async initialize() {
+        try {
+            const token = await this.tokenManager.getToken();
+            this.initialized = !!token;
+        }
+        catch (error) {
+            console.error('Failed to initialize auth:', error);
+            this.initialized = false;
+        }
+        finally {
+            this.initializationPromise = null;
+        }
+    }
+    async ensureInitialized() {
+        if (this.config.authType !== FlexbeAuthType.BEARER || this.initialized) {
+            return;
+        }
+        // If initialization is in progress, wait for it
+        if (this.initializationPromise) {
+            await this.initializationPromise;
+            return;
+        }
+        // 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 === 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;
+    }
+}

package/dist/esm/client/client.js

@@ -1,4 +1,6 @@
+import { FlexbeAuthType } from '../types';
 import { Pages } from './pages';
+import { ApiClient } from './api-client';
 export class FlexbeClient {
     constructor(config) {
         const getEnvVar = (key) => {
@@ -12,95 +14,12 @@ export class FlexbeClient {
             timeout: config?.timeout || 30000,
             apiKey: config?.apiKey || getEnvVar('FLEXBE_API_KEY') || '',
             siteId: config?.siteId || getEnvVar('FLEXBE_SITE_ID'),
+            authType: config?.authType || FlexbeAuthType.API_KEY,
         };
-        if (!this.config.apiKey) {
-            throw new Error('API key is required. Please provide it either through config or FLEXBE_API_KEY environment variable.');
+        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.');
         }
-        this.pages = new Pages(this);
-    }
-    buildUrl(path, params) {
-        const searchParams = new URLSearchParams();
-        if (params) {
-            Object.entries(params).forEach(([key, value]) => {
-                if (value !== undefined && value !== null) {
-                    searchParams.append(key, String(value));
-                }
-            });
-        }
-        return `${path}${searchParams.toString() ? `?${searchParams.toString()}` : ''}`;
-    }
-    async request(config) {
-        try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-            const url = this.buildUrl(config.url, config.params);
-            const response = await fetch(this.config.baseUrl + url, {
-                ...config,
-                headers: {
-                    'Authorization': `Bearer ${this.config.apiKey}`,
-                    'Content-Type': 'application/json',
-                    ...config.headers,
-                },
-                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();
-            return {
-                data,
-                status: response.status,
-                statusText: response.statusText,
-            };
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === 'AbortError') {
-                const timeoutError = {
-                    message: 'Request timeout',
-                    status: 408,
-                };
-                throw timeoutError;
-            }
-            throw error;
-        }
-    }
-    get(url, config) {
-        return this.request({ ...config, method: 'GET', url });
-    }
-    post(url, data, config) {
-        return this.request({ ...config, method: 'POST', url, body: JSON.stringify(data) });
-    }
-    put(url, data, config) {
-        return this.request({ ...config, method: 'PUT', url, body: JSON.stringify(data) });
-    }
-    delete(url, config) {
-        return this.request({ ...config, method: 'DELETE', url });
-    }
-    getSiteUrl(path) {
-        if (!this.config.siteId) {
-            return path;
-        }
-        return `/sites/${this.config.siteId}${path}`;
-    }
-    sitesGet(path, config) {
-        return this.get(this.getSiteUrl(path), config);
-    }
-    sitesPost(path, data, config) {
-        return this.post(this.getSiteUrl(path), data, config);
-    }
-    sitesPut(path, data, config) {
-        return this.put(this.getSiteUrl(path), data, config);
-    }
-    sitesDelete(path, config) {
-        return this.delete(this.getSiteUrl(path), config);
+        this.api = new ApiClient(this.config);
+        this.pages = new Pages(this.api);
     }
 }