@flexbe/sdk 0.1.1 → 0.1.2

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,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/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,12 @@
+import { FlexbeConfig } from '../types';
+export declare class FlexbeAuth {
+    private readonly config;
+    private readonly tokenManager;
+    private initialized;
+    private initializing;
+    constructor(config: FlexbeConfig);
+    private initializeBearerAuth;
+    ensureInitialized(): Promise<void>;
+    getAuthHeaders(): Promise<Record<string, string>>;
+    isInitialized(): boolean;
+}

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,15 @@
+import { TokenResponse } from '../types';
+export declare class TokenManager {
+    private static instance;
+    private token;
+    private refreshInterval;
+    private constructor();
+    static getInstance(): TokenManager;
+    private initializeFromStorage;
+    private setupStorageListener;
+    private getExpirationFromToken;
+    private startRefreshInterval;
+    setToken(tokenResponse: TokenResponse): void;
+    getToken(): string | null;
+    clearToken(): void;
+}

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

@@ -3,6 +3,7 @@ export interface FlexbeConfig {
     baseUrl?: string;
     timeout?: number;
     siteId?: string;
+    authType?: FlexbeAuthType;
 }
 export interface FlexbeResponse<T> {
     data: T;
@@ -20,4 +21,11 @@ export interface FlexbeError {
     status?: number;
     details?: unknown;
 }
-export type FlexbeAuthType = 'apiKey' | 'bearer' | 'oauth2';
+export type FlexbeAuthType = 'apiKey' | 'bearer';
+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.2",
     "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\"",