@flexbe/sdk 0.1.0 → 0.1.2

package/README.md

@@ -5,15 +5,15 @@ A TypeScript SDK for interacting with the Flexbe API. Works in both Node.js and
 ## Installation
 
 ```bash
-npm install @flexbe/sdk-ts
+npm install @flexbe/sdk
 ```
 
 ## Usage
 
 ```typescript
-import { FlexbeClient } from '@flexbe/sdk-ts';
+import { FlexbeClient } from '@flexbe/sdk';
 
-// Initialize the client
+// Initialize the client with API Key authentication
 const client = new FlexbeClient({
     apiKey: 'your-api-key',
     siteId: 'your-site-id', // optional, required for site-specific endpoints
@@ -21,6 +21,14 @@ const client = new FlexbeClient({
     timeout: 30000, // optional, defaults to 30 seconds
 });
 
+// Or initialize with JWT Bearer token authentication
+const client = new FlexbeClient({
+    authType: 'bearer',
+    siteId: 'your-site-id', // optional, required for site-specific endpoints
+    baseUrl: 'https://api.flexbe.com', // optional
+    timeout: 30000, // optional, defaults to 30 seconds
+});
+
 // Using the Pages API
 try {
     // Get list of pages
@@ -44,18 +52,21 @@ try {
 ## Features
 
 - TypeScript support with full type definitions
-- API Key authentication
+- Multiple authentication methods:
+  - API Key authentication
+  - JWT Bearer token authentication with automatic token refresh (uses cookie-based authentication)
 - Automatic error handling
 - Configurable timeout and base URL
 - Native fetch API support (works in both Node.js and browser)
 - Site-specific endpoints support
 - Query parameter handling
 - Request timeout handling
+- Token sharing between browser tabs (for JWT authentication)
 
 ## Environment Variables
 
 The SDK supports the following environment variables:
-- `FLEXBE_API_KEY`: Your API key
+- `FLEXBE_API_KEY`: Your API key (required for API Key authentication)
 - `FLEXBE_API_URL`: Base URL (defaults to 'https://api.flexbe.com')
 - `FLEXBE_SITE_ID`: Your site ID
 

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

@@ -0,0 +1,86 @@
+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());
+    });
+};
+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()}` : ''}`;
+    }
+    request(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 response = yield fetch(this.config.baseUrl + url, Object.assign(Object.assign({}, config), { headers, 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();
+                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(Object.assign(Object.assign({}, config), { method: 'GET', url }));
+    }
+    post(url, data, config) {
+        return this.request(Object.assign(Object.assign({}, config), { method: 'POST', url, body: JSON.stringify(data) }));
+    }
+    put(url, data, config) {
+        return this.request(Object.assign(Object.assign({}, config), { method: 'PUT', url, body: JSON.stringify(data) }));
+    }
+    delete(url, config) {
+        return this.request(Object.assign(Object.assign({}, config), { method: 'DELETE', url }));
+    }
+}

package/dist/browser/client/auth.js

@@ -0,0 +1,118 @@
+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());
+    });
+};
+import { TokenManager } from './token-manager';
+export class FlexbeAuth {
+    constructor(config) {
+        this.initialized = false;
+        this.initializing = false;
+        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
+        }
+        else {
+            this.initialized = true;
+        }
+    }
+    initializeBearerAuth() {
+        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;
+            }
+            catch (error) {
+                console.error('Failed to initialize bearer authentication:', error);
+                this.initialized = false; // Reset initialized state on error
+                throw error;
+            }
+            finally {
+                this.initializing = false;
+            }
+        });
+    }
+    ensureInitialized() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.config.authType !== 'bearer' || this.initialized) {
+                return;
+            }
+            yield this.initializeBearerAuth();
+        });
+    }
+    getAuthHeaders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureInitialized();
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            if (this.config.authType === 'apiKey') {
+                headers['x-api-key'] = this.config.apiKey;
+            }
+            else if (this.config.authType === 'bearer') {
+                const token = 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}`;
+                }
+            }
+            return headers;
+        });
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+}

package/dist/browser/client/client.js

@@ -1,13 +1,5 @@
-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());
-    });
-};
 import { Pages } from './pages';
+import { ApiClient } from './api-client';
 export class FlexbeClient {
     constructor(config) {
         const getEnvVar = (key) => {
@@ -21,89 +13,12 @@ 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',
         };
-        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()}` : ''}`;
-    }
-    request(config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-                const url = this.buildUrl(config.url, config.params);
-                const response = yield fetch(this.config.baseUrl + url, Object.assign(Object.assign({}, config), { headers: Object.assign({ '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 = 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();
-                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(Object.assign(Object.assign({}, config), { method: 'GET', url }));
-    }
-    post(url, data, config) {
-        return this.request(Object.assign(Object.assign({}, config), { method: 'POST', url, body: JSON.stringify(data) }));
-    }
-    put(url, data, config) {
-        return this.request(Object.assign(Object.assign({}, config), { method: 'PUT', url, body: JSON.stringify(data) }));
-    }
-    delete(url, config) {
-        return this.request(Object.assign(Object.assign({}, 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);
     }
 }

package/dist/browser/client/pages.js

@@ -8,15 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export class Pages {
-    constructor(client) {
-        this.client = client;
+    constructor(api) {
+        this.api = api;
     }
     /**
      * Get list of pages for a site
      */
     getPages(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.client.sitesGet('/pages', { params });
+            const response = yield this.api.get('/sites/:siteId:/pages', { params });
             return response.data;
         });
     }
@@ -25,7 +25,7 @@ export class Pages {
      */
     getPage(pageId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.client.sitesGet(`/pages/${pageId}`);
+            const response = yield this.api.get(`/sites/:siteId:/pages/${pageId}`);
             return response.data;
         });
     }

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

@@ -0,0 +1,132 @@
+const TOKEN_STORAGE_KEY = 'flexbe_jwt_token';
+const REFRESH_THRESHOLD = 0.8; // Refresh when 80% of token lifetime has passed
+export class TokenManager {
+    constructor() {
+        this.token = null;
+        this.refreshInterval = null;
+        this.initializeFromStorage();
+        this.setupStorageListener();
+    }
+    static getInstance() {
+        if (!TokenManager.instance) {
+            TokenManager.instance = new 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();
+                }
+            }
+        }
+    }
+    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();
+                    }
+                }
+            });
+        }
+    }
+    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
+        }
+    }
+    startRefreshInterval() {
+        if (this.refreshInterval) {
+            clearInterval(this.refreshInterval);
+        }
+        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);
+        }
+    }
+    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`,
+            expiresAt: new Date(expiresAt).toISOString(),
+        });
+        if (typeof window !== 'undefined') {
+            localStorage.setItem(TOKEN_STORAGE_KEY, JSON.stringify(this.token));
+        }
+        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;
+        }
+        if (typeof window !== 'undefined') {
+            localStorage.removeItem(TOKEN_STORAGE_KEY);
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const auth_1 = require("./auth");
+class ApiClient {
+    constructor(config) {
+        this.config = config;
+        this.auth = new auth_1.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 });
+    }
+}
+exports.ApiClient = ApiClient;