@vizzly/api-client 0.0.19 → 0.0.21

package/dist/models/Api.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Api = void 0;
 const isomorphic_fetch_1 = __importDefault(require("isomorphic-fetch"));
 const Monitor_1 = require("./Monitor");
+const VizzlyApiClientLogger_1 = require("./VizzlyApiClientLogger");
 class Api {
     constructor(auth, host, extraHeaders = () => ({})) {
         this.host = host;
@@ -37,10 +38,9 @@ class Api {
                 signal: request.abortSignal,
             });
             let body = ((_a = res.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('json')) ? yield res.json() : res.text();
-            const debugRequestId = res.headers.get('vizzly-query-engine-request-id') || res.headers.get('x-request-id');
-            if (debugRequestId && res.status != 200) {
-                console.debug(`[Vizzly Query Engine Request Id] ${debugRequestId}`);
-            }
+            const queryEngineRequestId = res.headers.get('vizzly-query-engine-request-id') || '-';
+            const vizzlyApiRequestId = res.headers.get('x-request-id') || '-';
+            VizzlyApiClientLogger_1.VizzlyApiClientLogger.debug(`[TRACING] QE; ${queryEngineRequestId} - API; ${vizzlyApiRequestId}`);
             return { body: body, status: res.status, headers: res.headers };
         });
     }

package/dist/models/DashboardRepository.d.ts

@@ -2,6 +2,7 @@ import { CreateDashboardParams, Dashboard, DashboardFromAPI, DashboardPermission
 import { Vizzly } from './Vizzly';
 export declare class DashboardRepository {
     private vizzly;
+    private repo;
     constructor(vizzly: Vizzly);
     createDashboard(createParams: CreateDashboardParams): Promise<{
         dashboard: Dashboard;

package/dist/models/DashboardRepository.js

@@ -16,9 +16,12 @@ const FailedToDecryptDashboardBeforeClient_1 = require("../errors/FailedToDecryp
 const FailedToFetchDashboardAccessTokens_1 = require("../errors/FailedToFetchDashboardAccessTokens");
 const FailedToUpdateDashboard_1 = require("../errors/FailedToUpdateDashboard");
 const Permission_1 = require("./Permission");
+const Repository_1 = require("./Repository");
 class DashboardRepository {
+    // private repo: { dashboards: Dashboard[]; permissions: DashboardPermission[] } | null;
     constructor(vizzly) {
         this.vizzly = vizzly;
+        this.repo = new Repository_1.Repository('id');
     }
     createDashboard(createParams) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -33,8 +36,10 @@ class DashboardRepository {
             }
             if (builtDashboard.status === 200) {
                 const formattedPermissions = builtDashboard.body.permissions.map(Permission_1.Permission.formatDashboardPermission);
+                const embellishedDashboard = DashboardRepository.embellishDashboardFromAPI(builtDashboard.body.dashboard, formattedPermissions);
+                this.repo.addItem(embellishedDashboard, formattedPermissions);
                 return {
-                    dashboard: DashboardRepository.embellishDashboardFromAPI(builtDashboard.body.dashboard, formattedPermissions),
+                    dashboard: embellishedDashboard,
                     permissions: formattedPermissions,
                 };
             }
@@ -59,11 +64,15 @@ class DashboardRepository {
                 updatedDashboard = yield vizzlyApi.execute(vizzlyApi.buildUpdateDashboardRequest(params));
             }
             if (updatedDashboard.status === 200) {
-                return DashboardRepository.embellishDashboardFromAPI(updatedDashboard.body.dashboard, [
+                const embellishedDashboard = DashboardRepository.embellishDashboardFromAPI(updatedDashboard.body.dashboard, [
                     params.dashboardPermission,
                 ]);
+                this.repo.updateItem(embellishedDashboard);
+                return embellishedDashboard;
+            }
+            else {
+                throw new FailedToUpdateDashboard_1.FailedToUpdateDashboard(`Failed to update dashboard, got status ${updatedDashboard.status}`);
             }
-            throw new FailedToUpdateDashboard_1.FailedToUpdateDashboard(`Failed to update dashboard, got status ${updatedDashboard.status}`);
         });
     }
     fetchDashboards(params) {
@@ -85,26 +94,32 @@ class DashboardRepository {
     fetchDashboardAccessTokens(params) {
         return __awaiter(this, void 0, void 0, function* () {
             let accessTokens;
-            if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
-                const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
-                accessTokens = yield vizzlyQueryEngineApi.execute(vizzlyQueryEngineApi.buildFetchDashboardAccessTokensRequest(params));
-            }
-            else {
-                const vizzlyApi = this.vizzly.getVizzlyAPI();
-                accessTokens = yield vizzlyApi.execute(vizzlyApi.buildFetchDashboardAccessTokensRequest(params));
-            }
-            if (accessTokens.status === 200) {
-                const formattedPermissions = accessTokens.body.permissions.map(Permission_1.Permission.formatDashboardPermission);
-                return {
-                    dashboards: accessTokens.body.dashboards.map((dashboard) => {
+            if (!this.repo.isPopulated()) {
+                if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
+                    const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
+                    accessTokens = yield vizzlyQueryEngineApi.execute(vizzlyQueryEngineApi.buildFetchDashboardAccessTokensRequest(params));
+                }
+                else {
+                    const vizzlyApi = this.vizzly.getVizzlyAPI();
+                    accessTokens = yield vizzlyApi.execute(vizzlyApi.buildFetchDashboardAccessTokensRequest(params));
+                }
+                if (accessTokens.status === 200) {
+                    const formattedPermissions = accessTokens.body.permissions.map(Permission_1.Permission.formatDashboardPermission);
+                    const embellishedDashboards = accessTokens.body.dashboards.map((dashboard) => {
                         if (typeof dashboard.definition === 'string')
                             throw new FailedToDecryptDashboardBeforeClient_1.FailedToDecryptDashboardBeforeClient();
                         return DashboardRepository.embellishDashboardFromAPI(dashboard, formattedPermissions);
-                    }),
-                    permissions: formattedPermissions,
-                };
+                    });
+                    this.repo.initRepo(embellishedDashboards, formattedPermissions);
+                }
+                else {
+                    throw new FailedToFetchDashboardAccessTokens_1.FailedToFetchDashboardAccessTokens('Failed to fetch dashboard access tokens.');
+                }
             }
-            throw new FailedToFetchDashboardAccessTokens_1.FailedToFetchDashboardAccessTokens('Failed to fetch dashboard access tokens.');
+            return {
+                dashboards: this.repo.getRepo().storedItems,
+                permissions: this.repo.getRepo().permissions,
+            };
         });
     }
 }

package/dist/models/GlobalLibraryRepository.d.ts

@@ -2,11 +2,11 @@ import { CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermission, Requ
 import { Vizzly } from './Vizzly';
 export declare class GlobalLibraryRepository {
     private vizzly;
-    private cachedPermissions;
+    private repo;
     constructor(vizzly: Vizzly);
     createGlobalLibrary(createParams: CreateGlobalLibraryParams): Promise<{
-        global_library: GlobalLibrary;
         permissions: GlobalLibraryPermission[];
+        global_library: GlobalLibrary;
     }>;
     fetchGlobalLibraries(params?: RequestParams): Promise<{
         global_libraries: GlobalLibrary[];

package/dist/models/GlobalLibraryRepository.js

@@ -13,21 +13,25 @@ exports.GlobalLibraryRepository = void 0;
 const lodash_1 = require("lodash");
 const Permission_1 = require("./Permission");
 const FailedToFetchGlobalLibraryAccessTokens_1 = require("../errors/FailedToFetchGlobalLibraryAccessTokens");
+const Repository_1 = require("./Repository");
 class GlobalLibraryRepository {
     constructor(vizzly) {
-        this.cachedPermissions = { permissions: [] };
         this.vizzly = vizzly;
+        this.repo = new Repository_1.Repository('id');
     }
     createGlobalLibrary(createParams) {
         return __awaiter(this, void 0, void 0, function* () {
             const vizzlyApi = this.vizzly.getVizzlyAPI();
+            let globalLibrary;
             if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
                 const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
-                return yield vizzlyQueryEngineApi.createGlobalLibrary(createParams);
+                globalLibrary = yield vizzlyQueryEngineApi.createGlobalLibrary(createParams);
             }
             else {
-                return yield vizzlyApi.createGlobalLibrary(createParams);
+                globalLibrary = yield vizzlyApi.createGlobalLibrary(createParams);
             }
+            this.repo.addItem(globalLibrary.global_library, globalLibrary.permissions);
+            return globalLibrary;
         });
     }
     fetchGlobalLibraries(params) {
@@ -40,32 +44,43 @@ class GlobalLibraryRepository {
         return __awaiter(this, void 0, void 0, function* () {
             const vizzlyApi = this.vizzly.getVizzlyAPI();
             let accessTokens;
-            if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
-                const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
-                accessTokens = yield vizzlyQueryEngineApi.fetchGlobalLibraryAccessTokens(params);
-            }
-            else {
-                accessTokens = yield vizzlyApi.fetchGlobalLibraryAccessTokens(params);
-            }
-            if (accessTokens.status === 200) {
-                return {
-                    global_libraries: accessTokens.body.global_libraries,
-                    permissions: accessTokens.body.permissions.map(Permission_1.Permission.formatGlobalLibraryPermission),
-                };
+            if (!this.repo.isPopulated()) {
+                if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
+                    const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
+                    accessTokens = yield vizzlyQueryEngineApi.fetchGlobalLibraryAccessTokens(params);
+                }
+                else {
+                    accessTokens = yield vizzlyApi.fetchGlobalLibraryAccessTokens(params);
+                }
+                if (accessTokens.status === 200) {
+                    const formattedPermissions = accessTokens.body.permissions.map(Permission_1.Permission.formatGlobalLibraryPermission);
+                    this.repo.initRepo(accessTokens.body.global_libraries, formattedPermissions);
+                }
+                else {
+                    throw new FailedToFetchGlobalLibraryAccessTokens_1.FailedToFetchGlobalLibraryAccessTokens('Failed to load access tokens for the global library.');
+                }
             }
-            throw new FailedToFetchGlobalLibraryAccessTokens_1.FailedToFetchGlobalLibraryAccessTokens('Failed to load access tokens for the global library.');
+            return {
+                global_libraries: this.repo.getRepo().storedItems,
+                permissions: this.repo.getRepo().permissions,
+            };
         });
     }
     updateGlobalLibrary(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const vizzlyApi = this.vizzly.getVizzlyAPI();
+            let updateResponse;
             if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
                 const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
-                return yield vizzlyQueryEngineApi.updateGlobalLibrary(params);
+                updateResponse = yield vizzlyQueryEngineApi.updateGlobalLibrary(params);
             }
             else {
-                return yield vizzlyApi.updateGlobalLibrary(params);
+                updateResponse = yield vizzlyApi.updateGlobalLibrary(params);
+            }
+            if (updateResponse.status === 200) {
+                this.repo.updateItem(updateResponse.body.global_library);
             }
+            return updateResponse;
         });
     }
     getChildGlobalLibrariesByParentGlobalLibraryId(parentGlobalLibraryId) {

package/dist/models/Permission.d.ts

@@ -7,4 +7,5 @@ export declare class Permission {
         scope: 'read' | 'read_write';
     }): DashboardPermission;
     static formatGlobalLibraryPermission(permission: GlobalLibraryPermissionFromAPI): GlobalLibraryPermission;
+    static validateJwtExpiry(token: string, freshnessBufferInSeconds?: number): boolean;
 }

package/dist/models/Permission.js

@@ -18,5 +18,25 @@ class Permission {
             globalLibraryId: permission.global_library_id,
         };
     }
+    static validateJwtExpiry(token, freshnessBufferInSeconds = 10) {
+        try {
+            // Split the token into its parts
+            const [_header, payload, _signature] = token.split('.');
+            // Decode the payload (Base64 decoding)
+            const decodedPayload = Buffer.from(payload, 'base64').toString('utf-8');
+            const payloadObj = JSON.parse(decodedPayload);
+            // Get the expiration time from the payload
+            const expirationTime = payloadObj.exp;
+            // Get the current timestamp
+            const currentTimestamp = Math.floor(Date.now() / 1000);
+            // Check if the token has expired
+            const hasExpired = expirationTime < currentTimestamp + freshnessBufferInSeconds;
+            return !hasExpired;
+        }
+        catch (error) {
+            // Token decoding or validation failed
+            return false;
+        }
+    }
 }
 exports.Permission = Permission;

package/dist/models/Repository.d.ts

@@ -0,0 +1,17 @@
+export declare class Repository<StoreType, PermissionType extends {
+    token: string;
+}> {
+    private storedItems;
+    private permissions;
+    private itemKey;
+    constructor(itemKey: keyof StoreType);
+    getRepo(): {
+        storedItems: StoreType[];
+        permissions: PermissionType[];
+    };
+    initRepo(storedItems: Array<StoreType>, permissions: Array<PermissionType>): void;
+    addItem(item: StoreType, permissions: PermissionType[]): void;
+    updateItem(newValue: StoreType): void;
+    isPopulated(): boolean;
+    private permissionsAreFresh;
+}

package/dist/models/Repository.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = void 0;
+const lodash_1 = require("lodash");
+const Permission_1 = require("./Permission");
+class Repository {
+    constructor(itemKey) {
+        this.itemKey = itemKey;
+        this.storedItems = [];
+        this.permissions = [];
+    }
+    getRepo() {
+        return {
+            storedItems: this.storedItems,
+            permissions: this.permissions,
+        };
+    }
+    initRepo(storedItems, permissions) {
+        this.storedItems = storedItems;
+        this.permissions = permissions;
+    }
+    addItem(item, permissions) {
+        // Can only add an item to the store that has been
+        // initialized using initRepo
+        if (this.isPopulated()) {
+            this.storedItems = [...this.storedItems, item];
+            this.permissions = [...this.permissions, ...permissions];
+        }
+    }
+    updateItem(newValue) {
+        this.storedItems = this.storedItems.map((item) => {
+            if (item[this.itemKey] == newValue[this.itemKey])
+                return newValue;
+            return item;
+        });
+    }
+    isPopulated() {
+        const populated = this.storedItems.length > 0 || this.permissions.length > 0;
+        return populated && this.permissionsAreFresh();
+    }
+    permissionsAreFresh() {
+        return (0, lodash_1.every)(this.permissions, (permission) => {
+            return Permission_1.Permission.validateJwtExpiry(permission.token);
+        });
+    }
+}
+exports.Repository = Repository;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizzly/api-client",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "private": false,
   "license": "NONE",
   "source": "src/index.ts",