@flexbe/sdk 0.1.1 → 0.1.3

package/dist/esm/client/pages.js

@@ -1,19 +1,19 @@
 export 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/esm/client/token-manager.js

@@ -0,0 +1,222 @@
+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();
+    }
+    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);
+        }
+    }
+}

package/dist/esm/types/index.js

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

package/dist/types/client/api-client.d.ts

@@ -0,0 +1,21 @@
+import { FlexbeConfig, FlexbeResponse } from '../types';
+export declare class ApiClient {
+    private readonly config;
+    private readonly auth;
+    constructor(config: FlexbeConfig);
+    private replaceSiteId;
+    private buildUrl;
+    private request;
+    get<T>(url: string, config?: RequestInit & {
+        params?: Record<string, unknown>;
+    }): Promise<FlexbeResponse<T>>;
+    post<T>(url: string, data?: unknown, config?: RequestInit & {
+        params?: Record<string, unknown>;
+    }): Promise<FlexbeResponse<T>>;
+    put<T>(url: string, data?: unknown, config?: RequestInit & {
+        params?: Record<string, unknown>;
+    }): Promise<FlexbeResponse<T>>;
+    delete<T>(url: string, config?: RequestInit & {
+        params?: Record<string, unknown>;
+    }): Promise<FlexbeResponse<T>>;
+}

package/dist/types/client/auth.d.ts

@@ -0,0 +1,11 @@
+import { FlexbeConfig } from '../types';
+export declare class FlexbeAuth {
+    private readonly config;
+    private readonly tokenManager;
+    private initialized;
+    private initializationPromise;
+    constructor(config: FlexbeConfig);
+    private initialize;
+    ensureInitialized(): Promise<void>;
+    getAuthHeaders(): Promise<Record<string, string>>;
+}

package/dist/types/client/client.d.ts

@@ -1,26 +1,9 @@
-import { FlexbeConfig, FlexbeResponse } from '../types';
+import { FlexbeConfig } from '../types';
 import { Pages } from './pages';
+import { ApiClient } from './api-client';
 export declare class FlexbeClient {
     private readonly config;
     readonly pages: Pages;
+    readonly api: ApiClient;
     constructor(config?: Partial<FlexbeConfig>);
-    private buildUrl;
-    private request;
-    private get;
-    private post;
-    private put;
-    private delete;
-    private getSiteUrl;
-    sitesGet<T>(path: string, config?: RequestInit & {
-        params?: Record<string, unknown>;
-    }): Promise<FlexbeResponse<T>>;
-    sitesPost<T>(path: string, data?: unknown, config?: RequestInit & {
-        params?: Record<string, unknown>;
-    }): Promise<FlexbeResponse<T>>;
-    sitesPut<T>(path: string, data?: unknown, config?: RequestInit & {
-        params?: Record<string, unknown>;
-    }): Promise<FlexbeResponse<T>>;
-    sitesDelete<T>(path: string, config?: RequestInit & {
-        params?: Record<string, unknown>;
-    }): Promise<FlexbeResponse<T>>;
 }

package/dist/types/client/pages.d.ts

@@ -1,8 +1,8 @@
 import { Page, GetPagesParams, PageListResponse } from '../types/pages';
-import { FlexbeClient } from './client';
+import { ApiClient } from './api-client';
 export declare class Pages {
-    private readonly client;
-    constructor(client: FlexbeClient);
+    private readonly api;
+    constructor(api: ApiClient);
     /**
      * Get list of pages for a site
      */

package/dist/types/client/token-manager.d.ts

@@ -0,0 +1,23 @@
+import { TokenResponse } from '../types';
+export declare class TokenManager {
+    private static instance;
+    private token;
+    private refreshInterval;
+    private refreshTimeout;
+    private tokenPromise;
+    private debug;
+    private constructor();
+    static getInstance(): TokenManager;
+    private initializeFromStorage;
+    private setupStorageListener;
+    private getExpirationFromToken;
+    getToken(): Promise<string | null>;
+    private retrieveToken;
+    private doRetrieveToken;
+    private startRefreshInterval;
+    private scheduleRefresh;
+    private clearRefreshTimers;
+    private logTokenStatus;
+    setToken(tokenResponse: TokenResponse): void;
+    clearToken(): void;
+}

package/dist/types/types/index.d.ts

@@ -1,8 +1,13 @@
+export declare enum FlexbeAuthType {
+    API_KEY = "apiKey",
+    BEARER = "bearer"
+}
 export interface FlexbeConfig {
     apiKey?: string;
     baseUrl?: string;
     timeout?: number;
     siteId?: string;
+    authType?: FlexbeAuthType;
 }
 export interface FlexbeResponse<T> {
     data: T;
@@ -20,4 +25,10 @@ export interface FlexbeError {
     status?: number;
     details?: unknown;
 }
-export type FlexbeAuthType = 'apiKey' | 'bearer' | 'oauth2';
+export interface JwtToken {
+    accessToken: string;
+    expiresAt: number;
+}
+export interface TokenResponse {
+    accessToken: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flexbe/sdk",
-    "version": "0.1.1",
+    "version": "0.1.3",
     "description": "TypeScript SDK for Flexbe API",
     "main": "dist/cjs/index.js",
     "module": "dist/esm/index.js",
@@ -18,6 +18,7 @@
         "build:esm": "tsc -p tsconfig.esm.json",
         "build:cjs": "tsc -p tsconfig.cjs.json",
         "build:browser": "tsc -p tsconfig.browser.json",
+        "dev": "tsc -p tsconfig.esm.json --watch",
         "test": "dotenv -e test/.env.test jest",
         "lint": "eslint src --ext .ts",
         "format": "prettier --write \"src/**/*.ts\"",