@flexbe/sdk 0.2.28 → 0.2.30

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

@@ -1,16 +1,9 @@
+import { UnauthorizedException } from '../types';
 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
+const TOKEN_REFRESH_THRESHOLD = 5 * 60 * 1000; // update token 5 minutes before expiration
 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) {
@@ -18,81 +11,59 @@ export class TokenManager {
         }
         return TokenManager.instance;
     }
-    initializeFromStorage() {
-        if (typeof window === 'undefined')
-            return;
-        const storedToken = localStorage.getItem(TOKEN_STORAGE_KEY);
-        if (!storedToken)
+    async getToken() {
+        const token = this.getStoredToken();
+        if (token && token.expiresAt > Date.now()) {
+            // TODO check if token expire less that 1 minute
+            // if so, retrieve a new token
+            if (token.expiresAt - Date.now() < TOKEN_REFRESH_THRESHOLD) {
+                void this.retrieveToken();
+            }
+            return token.accessToken;
+        }
+        await this.retrieveToken();
+        const retrievedToken = this.getStoredToken();
+        return retrievedToken?.accessToken ?? null;
+    }
+    async revokeToken() {
+        const token = this.getStoredToken();
+        this.clearToken();
+        if (!token)
             return;
         try {
-            this.token = JSON.parse(storedToken);
-            if (this.token.expiresAt > Date.now()) {
-                this.logTokenStatus('Token loaded from storage');
-                this.startRefreshInterval();
-            }
-            else {
-                this.clearToken();
-            }
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 30000);
+            await fetch('/oauth/revoke', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${token.accessToken}`
+                },
+                body: JSON.stringify({ token: token.accessToken }),
+                credentials: 'include',
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
         }
         catch (error) {
-            console.error('Failed to parse stored token:', error);
-            this.clearToken();
+            console.error('Failed to revoke token:', error);
         }
     }
-    setupStorageListener() {
+    getStoredToken() {
         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) {
+            return null;
+        const storedToken = localStorage.getItem(TOKEN_STORAGE_KEY);
+        if (!storedToken) {
+            return null;
+        }
         try {
-            const [, payload] = token.split('.');
-            const decodedPayload = JSON.parse(atob(payload));
-            return decodedPayload.exp * 1000; // Convert to milliseconds
+            const token = JSON.parse(storedToken);
+            return token;
         }
         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;
+            console.error('getStoredToken: Failed to parse stored token:', error);
+            return null;
         }
-        await this.retrieveToken();
-        return this.token?.accessToken ?? null;
     }
     async retrieveToken() {
         if (this.tokenPromise) {
@@ -121,131 +92,43 @@ export class TokenManager {
             clearTimeout(timeoutId);
             if (!response.ok) {
                 const errorData = await response.json().catch(() => ({ message: response.statusText }));
+                if (response.status === 401) {
+                    throw new UnauthorizedException(errorData.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();
-            // 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.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 = {
+        const 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);
+            localStorage.setItem(TOKEN_STORAGE_KEY, JSON.stringify(token));
         }
     }
-    async revokeToken() {
-        const token = this.token;
-        this.clearToken();
-        if (!token)
-            return;
+    getExpirationFromToken(token) {
         try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), 30000);
-            await fetch('/oauth/revoke', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${token.accessToken}`
-                },
-                body: JSON.stringify({ token: token.accessToken }),
-                credentials: 'include',
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
+            const [, payload] = token.split('.');
+            const decodedPayload = JSON.parse(atob(payload));
+            return decodedPayload.exp * 1000; // Convert to milliseconds
         }
         catch (error) {
-            console.error('Failed to revoke token:', error);
-            // Even if revocation fails, we still want to clear the local token
+            console.error('getExpirationFromToken: Failed to parse token expiration:', error);
+            return Date.now() + (4 * 60 * 1000); // Default to 4 minutes if parsing fails
+        }
+    }
+    clearToken() {
+        if (typeof window === 'undefined') {
+            return;
         }
+        localStorage.removeItem(TOKEN_STORAGE_KEY);
     }
 }

package/dist/esm/types/index.js

@@ -4,44 +4,56 @@ export var FlexbeAuthType;
     FlexbeAuthType["BEARER"] = "bearer";
 })(FlexbeAuthType || (FlexbeAuthType = {}));
 export class NotFoundException extends Error {
-    constructor(message) {
+    constructor(message, error, errors) {
         super(Array.isArray(message) ? message.join(', ') : message);
         this.statusCode = 404;
         this.name = 'NotFoundException';
+        this.error = error || 'not_found';
+        this.errors = errors;
     }
 }
 export class ForbiddenException extends Error {
-    constructor(message) {
+    constructor(message, error, errors) {
         super(Array.isArray(message) ? message.join(', ') : message);
         this.statusCode = 403;
         this.name = 'ForbiddenException';
+        this.error = error || 'forbidden';
+        this.errors = errors;
     }
 }
 export class BadRequestException extends Error {
-    constructor(message) {
+    constructor(message, error, errors) {
         super(Array.isArray(message) ? message.join(', ') : message);
         this.statusCode = 400;
         this.name = 'BadRequestException';
+        this.error = error || 'bad_request';
+        this.errors = errors;
     }
 }
 export class UnauthorizedException extends Error {
-    constructor(message) {
+    constructor(message, error, errors) {
         super(Array.isArray(message) ? message.join(', ') : message);
         this.statusCode = 401;
         this.name = 'UnauthorizedException';
+        this.error = error || 'unauthorized';
+        this.errors = errors;
     }
 }
 export class ServerException extends Error {
-    constructor(message, statusCode = 500) {
+    constructor(message, error, statusCode = 500, errors) {
         super(Array.isArray(message) ? message.join(', ') : message);
         this.name = 'ServerException';
+        this.error = error || 'server_error';
         this.statusCode = statusCode;
+        this.errors = errors;
     }
 }
 export class TimeoutException extends Error {
-    constructor(message) {
+    constructor(message, error, errors) {
         super(Array.isArray(message) ? message.join(', ') : message);
         this.statusCode = 408;
         this.name = 'TimeoutException';
+        this.error = error || 'timeout';
+        this.errors = errors;
     }
 }

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

@@ -1,8 +1,9 @@
 import { FlexbeConfig, FlexbeResponse } from '../types';
 export declare class ApiClient {
     private readonly config;
-    private readonly auth;
+    private readonly tokenManager;
     constructor(config: FlexbeConfig);
+    private getAuthHeaders;
     private buildUrl;
     private request;
     get<T>(url: string, config?: RequestInit & {

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

@@ -1,24 +1,13 @@
-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>;
+    revokeToken(): Promise<void>;
+    private getStoredToken;
     private retrieveToken;
     private doRetrieveToken;
-    private startRefreshInterval;
-    private scheduleRefresh;
-    private clearRefreshTimers;
-    private logTokenStatus;
-    setToken(tokenResponse: TokenResponse): void;
-    clearToken(): void;
-    revokeToken(): Promise<void>;
+    private setToken;
+    private getExpirationFromToken;
+    private clearToken;
 }

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

@@ -8,6 +8,9 @@ export interface FlexbeConfig {
     timeout?: number;
     siteId?: string;
     authType?: FlexbeAuthType;
+    hooks?: {
+        onUnauthorized?: () => void;
+    };
 }
 export interface FlexbeResponse<T> {
     data: T;
@@ -18,11 +21,19 @@ export interface FlexbeErrorResponse {
     message: string | string[];
     error: string;
     statusCode: number;
+    errors?: FlexbeBulkError[];
 }
 export interface FlexbeError {
     message: string | string[];
     error: string;
     statusCode: number;
+    errors?: FlexbeBulkError[];
+}
+export interface FlexbeBulkError {
+    id: number;
+    message: string;
+    error: string;
+    code: number;
 }
 export interface JwtToken {
     accessToken: string;
@@ -38,26 +49,38 @@ export interface Pagination {
 }
 export declare class NotFoundException extends Error {
     readonly statusCode = 404;
-    constructor(message: string | string[]);
+    readonly errors?: FlexbeBulkError[];
+    readonly error: string;
+    constructor(message: string | string[], error?: string, errors?: FlexbeBulkError[]);
 }
 export declare class ForbiddenException extends Error {
     readonly statusCode = 403;
-    constructor(message: string | string[]);
+    readonly errors?: FlexbeBulkError[];
+    readonly error: string;
+    constructor(message: string | string[], error?: string, errors?: FlexbeBulkError[]);
 }
 export declare class BadRequestException extends Error {
     readonly statusCode = 400;
-    constructor(message: string | string[]);
+    readonly errors?: FlexbeBulkError[];
+    readonly error: string;
+    constructor(message: string | string[], error?: string, errors?: FlexbeBulkError[]);
 }
 export declare class UnauthorizedException extends Error {
     readonly statusCode = 401;
-    constructor(message: string | string[]);
+    readonly errors?: FlexbeBulkError[];
+    readonly error: string;
+    constructor(message: string | string[], error?: string, errors?: FlexbeBulkError[]);
 }
 export declare class ServerException extends Error {
     readonly statusCode: number;
-    constructor(message: string | string[], statusCode?: number);
+    readonly errors?: FlexbeBulkError[];
+    readonly error: string;
+    constructor(message: string | string[], error?: string, statusCode?: number, errors?: FlexbeBulkError[]);
 }
 export declare class TimeoutException extends Error {
     readonly statusCode = 408;
-    constructor(message: string | string[]);
+    readonly errors?: FlexbeBulkError[];
+    readonly error: string;
+    constructor(message: string | string[], error?: string, errors?: FlexbeBulkError[]);
 }
 export type SiteApi = import('../client/site-api').SiteApi;

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

@@ -1,4 +1,4 @@
-import { Pagination } from './index';
+import { FlexbeBulkError, Pagination } from './index';
 export interface GridConfig {
     color?: string;
     desktop?: {
@@ -99,14 +99,9 @@ export interface UpdatePageParams {
 export interface BulkUpdatePageItem extends UpdatePageParams {
     id: number;
 }
-export interface BulkUpdateError {
-    id: number;
-    code: number;
-    message: string;
-}
 export interface BulkUpdateResponse {
     updated: Page[];
-    errors: BulkUpdateError[];
+    errors: FlexbeBulkError[];
 }
 export interface BulkUpdateFolderItem extends UpdateFolderParams {
     id: number;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flexbe/sdk",
-    "version": "0.2.28",
+    "version": "0.2.30",
     "description": "TypeScript SDK for Flexbe API",
     "main": "dist/cjs/index.js",
     "module": "dist/esm/index.js",
@@ -24,8 +24,7 @@
         "format": "prettier --write \"src/**/*.ts\"",
         "prepare": "npm run build",
         "prepublishOnly": "npm test && npm run lint",
-        "version": "npm version",
-        "publish": "npm publish --access public"
+        "version": "npm version"
     },
     "keywords": [
         "flexbe",