@flexbe/sdk 0.2.22 → 0.2.24

package/dist/browser/client/client.js

@@ -1,7 +1,17 @@
+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 { FlexbeAuthType } from '../types';
 import { ApiClient } from './api-client';
 import { SiteApi } from './site-api';
 import { MetaApi } from './meta-api';
+import { TokenManager } from './token-manager';
 export class FlexbeClient {
     constructor(config) {
         this.siteApis = new Map();
@@ -36,4 +46,17 @@ export class FlexbeClient {
         }
         return siteApi;
     }
+    /**
+     * Revokes the current authentication token and clears it from storage.
+     * This should be called during logout to ensure proper cleanup.
+     * @returns Promise that resolves when the token is revoked
+     */
+    revokeToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.config.authType !== FlexbeAuthType.BEARER) {
+                return;
+            }
+            yield TokenManager.getInstance().revokeToken();
+        });
+    }
 }

package/dist/browser/client/pages.js

@@ -272,4 +272,95 @@ export class Pages {
             return response.data;
         });
     }
+    /**
+     * Get all AB tests for a page
+     * @param pageId - ID of the page to get AB tests for
+     * @returns Array of AB tests
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    getAbTests(pageId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.api.get(`/sites/${this.siteId}/pages/${pageId}/abtests`);
+            return response.data;
+        });
+    }
+    /**
+     * Get a single AB test by ID
+     * @param pageId - ID of the page the AB test belongs to
+     * @param testId - ID of the AB test to get
+     * @returns The requested AB test
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page or AB test is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    getAbTest(pageId, testId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.api.get(`/sites/${this.siteId}/pages/${pageId}/abtests/${testId}`);
+            return response.data;
+        });
+    }
+    /**
+     * Create a new AB test
+     * @param pageId - ID of the page to create the AB test for
+     * @param data - Create parameters:
+     * - isActive: Whether the test is active (optional, defaults to true)
+     * @returns The created AB test
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {BadRequestException} When the create parameters are invalid
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    createAbTest(pageId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.api.post(`/sites/${this.siteId}/pages/${pageId}/abtests`, data);
+            return response.data;
+        });
+    }
+    /**
+     * Update an AB test
+     * @param pageId - ID of the page the AB test belongs to
+     * @param testId - ID of the AB test to update
+     * @param data - Update parameters:
+     * - isActive: Whether the test is active
+     * - aCountView: Number of views for variant A
+     * - aCountLead: Number of leads for variant A
+     * - bCountView: Number of views for variant B
+     * - bCountLead: Number of leads for variant B
+     * @returns The updated AB test
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page or AB test is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {BadRequestException} When the update parameters are invalid
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    updateAbTest(pageId, testId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.api.put(`/sites/${this.siteId}/pages/${pageId}/abtests/${testId}`, data);
+            return response.data;
+        });
+    }
+    /**
+     * Delete an AB test
+     * @param pageId - ID of the page the AB test belongs to
+     * @param testId - ID of the AB test to delete
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page or AB test is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    deleteAbTest(pageId, testId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.api.delete(`/sites/${this.siteId}/pages/${pageId}/abtests/${testId}`);
+        });
+    }
 }

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

@@ -235,4 +235,31 @@ export class TokenManager {
             localStorage.removeItem(TOKEN_STORAGE_KEY);
         }
     }
+    revokeToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = this.token;
+            this.clearToken();
+            if (!token)
+                return;
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 30000);
+                yield 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 revoke token:', error);
+                // Even if revocation fails, we still want to clear the local token
+            }
+        });
+    }
 }

package/dist/cjs/client/client.js

@@ -5,6 +5,7 @@ const types_1 = require("../types");
 const api_client_1 = require("./api-client");
 const site_api_1 = require("./site-api");
 const meta_api_1 = require("./meta-api");
+const token_manager_1 = require("./token-manager");
 class FlexbeClient {
     constructor(config) {
         this.siteApis = new Map();
@@ -39,5 +40,16 @@ class FlexbeClient {
         }
         return siteApi;
     }
+    /**
+     * Revokes the current authentication token and clears it from storage.
+     * This should be called during logout to ensure proper cleanup.
+     * @returns Promise that resolves when the token is revoked
+     */
+    async revokeToken() {
+        if (this.config.authType !== types_1.FlexbeAuthType.BEARER) {
+            return;
+        }
+        await token_manager_1.TokenManager.getInstance().revokeToken();
+    }
 }
 exports.FlexbeClient = FlexbeClient;

package/dist/cjs/client/pages.js

@@ -242,5 +242,86 @@ class Pages {
         const response = await this.api.put(`/sites/${this.siteId}/pages/${pageId}/content`, content);
         return response.data;
     }
+    /**
+     * Get all AB tests for a page
+     * @param pageId - ID of the page to get AB tests for
+     * @returns Array of AB tests
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async getAbTests(pageId) {
+        const response = await this.api.get(`/sites/${this.siteId}/pages/${pageId}/abtests`);
+        return response.data;
+    }
+    /**
+     * Get a single AB test by ID
+     * @param pageId - ID of the page the AB test belongs to
+     * @param testId - ID of the AB test to get
+     * @returns The requested AB test
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page or AB test is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async getAbTest(pageId, testId) {
+        const response = await this.api.get(`/sites/${this.siteId}/pages/${pageId}/abtests/${testId}`);
+        return response.data;
+    }
+    /**
+     * Create a new AB test
+     * @param pageId - ID of the page to create the AB test for
+     * @param data - Create parameters:
+     * - isActive: Whether the test is active (optional, defaults to true)
+     * @returns The created AB test
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {BadRequestException} When the create parameters are invalid
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async createAbTest(pageId, data) {
+        const response = await this.api.post(`/sites/${this.siteId}/pages/${pageId}/abtests`, data);
+        return response.data;
+    }
+    /**
+     * Update an AB test
+     * @param pageId - ID of the page the AB test belongs to
+     * @param testId - ID of the AB test to update
+     * @param data - Update parameters:
+     * - isActive: Whether the test is active
+     * - aCountView: Number of views for variant A
+     * - aCountLead: Number of leads for variant A
+     * - bCountView: Number of views for variant B
+     * - bCountLead: Number of leads for variant B
+     * @returns The updated AB test
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page or AB test is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {BadRequestException} When the update parameters are invalid
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async updateAbTest(pageId, testId, data) {
+        const response = await this.api.put(`/sites/${this.siteId}/pages/${pageId}/abtests/${testId}`, data);
+        return response.data;
+    }
+    /**
+     * Delete an AB test
+     * @param pageId - ID of the page the AB test belongs to
+     * @param testId - ID of the AB test to delete
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page or AB test is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async deleteAbTest(pageId, testId) {
+        await this.api.delete(`/sites/${this.siteId}/pages/${pageId}/abtests/${testId}`);
+    }
 }
 exports.Pages = Pages;

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

@@ -226,5 +226,30 @@ class TokenManager {
             localStorage.removeItem(TOKEN_STORAGE_KEY);
         }
     }
+    async revokeToken() {
+        const token = this.token;
+        this.clearToken();
+        if (!token)
+            return;
+        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);
+        }
+        catch (error) {
+            console.error('Failed to revoke token:', error);
+            // Even if revocation fails, we still want to clear the local token
+        }
+    }
 }
 exports.TokenManager = TokenManager;

package/dist/esm/client/client.js

@@ -2,6 +2,7 @@ import { FlexbeAuthType } from '../types';
 import { ApiClient } from './api-client';
 import { SiteApi } from './site-api';
 import { MetaApi } from './meta-api';
+import { TokenManager } from './token-manager';
 export class FlexbeClient {
     constructor(config) {
         this.siteApis = new Map();
@@ -36,4 +37,15 @@ export class FlexbeClient {
         }
         return siteApi;
     }
+    /**
+     * Revokes the current authentication token and clears it from storage.
+     * This should be called during logout to ensure proper cleanup.
+     * @returns Promise that resolves when the token is revoked
+     */
+    async revokeToken() {
+        if (this.config.authType !== FlexbeAuthType.BEARER) {
+            return;
+        }
+        await TokenManager.getInstance().revokeToken();
+    }
 }

package/dist/esm/client/pages.js

@@ -239,4 +239,85 @@ export class Pages {
         const response = await this.api.put(`/sites/${this.siteId}/pages/${pageId}/content`, content);
         return response.data;
     }
+    /**
+     * Get all AB tests for a page
+     * @param pageId - ID of the page to get AB tests for
+     * @returns Array of AB tests
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async getAbTests(pageId) {
+        const response = await this.api.get(`/sites/${this.siteId}/pages/${pageId}/abtests`);
+        return response.data;
+    }
+    /**
+     * Get a single AB test by ID
+     * @param pageId - ID of the page the AB test belongs to
+     * @param testId - ID of the AB test to get
+     * @returns The requested AB test
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page or AB test is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async getAbTest(pageId, testId) {
+        const response = await this.api.get(`/sites/${this.siteId}/pages/${pageId}/abtests/${testId}`);
+        return response.data;
+    }
+    /**
+     * Create a new AB test
+     * @param pageId - ID of the page to create the AB test for
+     * @param data - Create parameters:
+     * - isActive: Whether the test is active (optional, defaults to true)
+     * @returns The created AB test
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {BadRequestException} When the create parameters are invalid
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async createAbTest(pageId, data) {
+        const response = await this.api.post(`/sites/${this.siteId}/pages/${pageId}/abtests`, data);
+        return response.data;
+    }
+    /**
+     * Update an AB test
+     * @param pageId - ID of the page the AB test belongs to
+     * @param testId - ID of the AB test to update
+     * @param data - Update parameters:
+     * - isActive: Whether the test is active
+     * - aCountView: Number of views for variant A
+     * - aCountLead: Number of leads for variant A
+     * - bCountView: Number of views for variant B
+     * - bCountLead: Number of leads for variant B
+     * @returns The updated AB test
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page or AB test is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {BadRequestException} When the update parameters are invalid
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async updateAbTest(pageId, testId, data) {
+        const response = await this.api.put(`/sites/${this.siteId}/pages/${pageId}/abtests/${testId}`, data);
+        return response.data;
+    }
+    /**
+     * Delete an AB test
+     * @param pageId - ID of the page the AB test belongs to
+     * @param testId - ID of the AB test to delete
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page or AB test is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async deleteAbTest(pageId, testId) {
+        await this.api.delete(`/sites/${this.siteId}/pages/${pageId}/abtests/${testId}`);
+    }
 }

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

@@ -223,4 +223,29 @@ export class TokenManager {
             localStorage.removeItem(TOKEN_STORAGE_KEY);
         }
     }
+    async revokeToken() {
+        const token = this.token;
+        this.clearToken();
+        if (!token)
+            return;
+        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);
+        }
+        catch (error) {
+            console.error('Failed to revoke token:', error);
+            // Even if revocation fails, we still want to clear the local token
+        }
+    }
 }

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

@@ -13,4 +13,10 @@ export declare class FlexbeClient {
      * @returns A SiteApi instance for the specified site
      */
     getSiteApi(siteId: number): SiteApi;
+    /**
+     * Revokes the current authentication token and clears it from storage.
+     * This should be called during logout to ensure proper cleanup.
+     * @returns Promise that resolves when the token is revoked
+     */
+    revokeToken(): Promise<void>;
 }

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

@@ -1,4 +1,4 @@
-import { Page, GetPagesParams, PageListResponse, PageFolder, PageFolderListResponse, UpdateFolderParams, CreateFolderParams, UpdatePageParams, BulkUpdatePageItem, BulkUpdateResponse, BulkUpdateFolderItem, BulkUpdateFolderResponse, BulkDeleteResponse, PageContent, UpdatePageContentParams } from '../types/pages';
+import { Page, GetPagesParams, PageListResponse, PageFolder, PageFolderListResponse, UpdateFolderParams, CreateFolderParams, UpdatePageParams, BulkUpdatePageItem, BulkUpdateResponse, BulkUpdateFolderItem, BulkUpdateFolderResponse, BulkDeleteResponse, PageContent, UpdatePageContentParams, AbTest, CreateAbTestParams, UpdateAbTestParams } from '../types/pages';
 import { ApiClient } from './api-client';
 export declare class Pages {
     private readonly api;
@@ -193,4 +193,71 @@ export declare class Pages {
      * @throws {TimeoutException} When the request times out
      */
     updatePageContent(pageId: number, content: Partial<UpdatePageContentParams>): Promise<PageContent>;
+    /**
+     * Get all AB tests for a page
+     * @param pageId - ID of the page to get AB tests for
+     * @returns Array of AB tests
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    getAbTests(pageId: number): Promise<AbTest[]>;
+    /**
+     * Get a single AB test by ID
+     * @param pageId - ID of the page the AB test belongs to
+     * @param testId - ID of the AB test to get
+     * @returns The requested AB test
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page or AB test is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    getAbTest(pageId: number, testId: number): Promise<AbTest>;
+    /**
+     * Create a new AB test
+     * @param pageId - ID of the page to create the AB test for
+     * @param data - Create parameters:
+     * - isActive: Whether the test is active (optional, defaults to true)
+     * @returns The created AB test
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {BadRequestException} When the create parameters are invalid
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    createAbTest(pageId: number, data: CreateAbTestParams): Promise<AbTest>;
+    /**
+     * Update an AB test
+     * @param pageId - ID of the page the AB test belongs to
+     * @param testId - ID of the AB test to update
+     * @param data - Update parameters:
+     * - isActive: Whether the test is active
+     * - aCountView: Number of views for variant A
+     * - aCountLead: Number of leads for variant A
+     * - bCountView: Number of views for variant B
+     * - bCountLead: Number of leads for variant B
+     * @returns The updated AB test
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page or AB test is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {BadRequestException} When the update parameters are invalid
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    updateAbTest(pageId: number, testId: number, data: UpdateAbTestParams): Promise<AbTest>;
+    /**
+     * Delete an AB test
+     * @param pageId - ID of the page the AB test belongs to
+     * @param testId - ID of the AB test to delete
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page or AB test is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    deleteAbTest(pageId: number, testId: number): Promise<void>;
 }

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

@@ -20,4 +20,5 @@ export declare class TokenManager {
     private logTokenStatus;
     setToken(tokenResponse: TokenResponse): void;
     clearToken(): void;
+    revokeToken(): Promise<void>;
 }

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

@@ -292,4 +292,24 @@ export interface PageContent {
     };
 }
 export type UpdatePageContentParams = Omit<PageContent, 'versionId' | 'versionTime'>;
+export interface AbTest {
+    id: number;
+    a: string;
+    b: string;
+    isActive: boolean;
+    aCountView?: number;
+    aCountLead?: number;
+    bCountView?: number;
+    bCountLead?: number;
+}
+export interface CreateAbTestParams {
+    isActive?: boolean;
+}
+export interface UpdateAbTestParams {
+    isActive?: boolean;
+    aCountView?: number;
+    aCountLead?: number;
+    bCountView?: number;
+    bCountLead?: number;
+}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flexbe/sdk",
-    "version": "0.2.22",
+    "version": "0.2.24",
     "description": "TypeScript SDK for Flexbe API",
     "main": "dist/cjs/index.js",
     "module": "dist/esm/index.js",