@vizzly/api-client 0.0.10 → 0.0.12

package/dist/models/Authentication.js

@@ -42,7 +42,6 @@ class Authentication {
     }
     buildAuthHeaders() {
         if (this.authParams.dashboardAccessToken) {
-            console.debug('Using dashboard access token');
             return {
                 auth: `Bearer ${this.authParams.dashboardAccessToken}`,
             };
@@ -51,19 +50,16 @@ class Authentication {
         // of fetching one. This is most likely used on the managed query-engine where we
         // pass the project access token through in a request header.
         if (this.authParams.projectAccessToken) {
-            console.debug('Using project access token for auth header');
             return {
                 auth: `Bearer ${this.authParams.projectAccessToken}`,
             };
         }
         if (this.authParams.projectApiKey) {
-            console.debug('Using API Key for auth header');
             return {
                 auth: `Api-Key ${this.authParams.projectApiKey}`,
             };
         }
         if (this.authParams.appSessionToken) {
-            console.debug('Using app session access token');
             return {
                 auth: `Bearer ${this.authParams.appSessionToken}`,
             };

package/dist/models/DashboardManager.js

@@ -27,10 +27,7 @@ class DashboardManager {
             var _a, _b, _c;
             const dashboardRepository = this.vizzly.getDashboardRepository();
             const globalLibraryRepository = this.vizzly.getGlobalLibraryRepository();
-            const { permissions: dashboardPermissions } = yield dashboardRepository.fetchDashboardAccessTokens();
-            const { permissions: globalLibraryPermissions } = yield globalLibraryRepository.fetchGlobalLibraryAccessTokens();
-            const { found: globalLibraries } = yield globalLibraryRepository.fetchGlobalLibraries();
-            const { found: dashboards } = yield dashboardRepository.fetchDashboards();
+            const [{ global_libraries: globalLibraries, permissions: globalLibraryPermissions }, { dashboards, permissions: dashboardPermissions },] = yield Promise.all([globalLibraryRepository.fetchGlobalLibraries(), dashboardRepository.fetchDashboards()]);
             const dashboardToUpdate = dashboards.find((dashboard) => dashboard.id === params.dashboardId);
             if (!dashboardToUpdate)
                 throw new Error('Cannot find dashboard to update.');
@@ -97,8 +94,8 @@ class DashboardManager {
         return __awaiter(this, void 0, void 0, function* () {
             const dashboardRepo = this.vizzly.getDashboardRepository();
             const libraryRepo = this.vizzly.getGlobalLibraryRepository();
-            const { found: dashboards } = yield dashboardRepo.fetchDashboards();
-            const { found: globalLibraries } = yield libraryRepo.fetchGlobalLibraries();
+            const { dashboards } = yield dashboardRepo.fetchDashboards();
+            const { global_libraries: globalLibraries } = yield libraryRepo.fetchGlobalLibraries();
             return DashboardManager.mergeDashboardsAndGlobalLibraries(dashboards, globalLibraries);
         });
     }

package/dist/models/DashboardRepository.d.ts

@@ -9,13 +9,14 @@ export declare class DashboardRepository {
     }>;
     updateDashboard(params: UpdateDashboardParams): Promise<Dashboard>;
     fetchDashboards(): Promise<{
-        found: Dashboard[];
-        not_found: string[];
+        dashboards: Dashboard[];
+        permissions: DashboardPermission[];
     }>;
     static embellishDashboardFromAPI(dashboard: DashboardFromAPI, permissions: DashboardPermission[]): Dashboard;
     static takeHighestPermission(dashboardId: string, permissions: DashboardPermission[]): DashboardPermission;
     static takePermissionsOfScope(dashboardId: string, permissions: DashboardPermission[], scope: 'read' | 'read_write'): DashboardPermission[];
     fetchDashboardAccessTokens(): Promise<{
+        dashboards: Dashboard[];
         permissions: DashboardPermission[];
     }>;
 }

package/dist/models/DashboardRepository.js

@@ -14,7 +14,6 @@ const DashboardQuotaReached_1 = require("../errors/DashboardQuotaReached");
 const FailedToCreateDashboard_1 = require("../errors/FailedToCreateDashboard");
 const FailedToDecryptDashboardBeforeClient_1 = require("../errors/FailedToDecryptDashboardBeforeClient");
 const FailedToFetchDashboardAccessTokens_1 = require("../errors/FailedToFetchDashboardAccessTokens");
-const FailedToFetchDashboards_1 = require("../errors/FailedToFetchDashboards");
 const FailedToUpdateDashboard_1 = require("../errors/FailedToUpdateDashboard");
 const Permission_1 = require("./Permission");
 class DashboardRepository {
@@ -69,28 +68,33 @@ class DashboardRepository {
     }
     fetchDashboards() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { permissions } = yield this.fetchDashboardAccessTokens();
-            let dashboardResponse;
-            if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
-                const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
-                dashboardResponse = yield vizzlyQueryEngineApi.execute(vizzlyQueryEngineApi.buildFetchDashboardsRequest(permissions.map((p) => p.token)));
-            }
-            else {
-                const vizzlyApi = this.vizzly.getVizzlyAPI();
-                dashboardResponse = yield vizzlyApi.execute(vizzlyApi.buildFetchDashboardsRequest(permissions.map((p) => p.token)));
-            }
-            if (dashboardResponse.status === 200) {
-                dashboardResponse.body.found.forEach((dashboard) => {
-                    if (typeof dashboard.definition === 'string') {
-                        throw new FailedToDecryptDashboardBeforeClient_1.FailedToDecryptDashboardBeforeClient();
-                    }
-                });
-                return {
-                    found: dashboardResponse.body.found.map((foundDashboard) => DashboardRepository.embellishDashboardFromAPI(foundDashboard, permissions)),
-                    not_found: dashboardResponse.body.not_found,
-                };
-            }
-            throw new FailedToFetchDashboards_1.FailedToFetchDashboards(`Failed to fetch dashboards. Got status code ${dashboardResponse.status}.`);
+            return yield this.fetchDashboardAccessTokens();
+            // let dashboardResponse: Response<FetchDashboardsResponseBody>;
+            // if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
+            //   const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
+            //   dashboardResponse = await vizzlyQueryEngineApi.execute<FetchDashboardsResponseBody>(
+            //     vizzlyQueryEngineApi.buildFetchDashboardsRequest(permissions.map((p) => p.token))
+            //   );
+            // } else {
+            //   const vizzlyApi = this.vizzly.getVizzlyAPI();
+            //   dashboardResponse = await vizzlyApi.execute<{ found: Dashboard[]; not_found: any[] }>(
+            //     vizzlyApi.buildFetchDashboardsRequest(permissions.map((p) => p.token))
+            //   );
+            // }
+            // if (dashboardResponse.status === 200) {
+            // dashboardResponse.body.found.forEach((dashboard) => {
+            //   if (typeof dashboard.definition === 'string') {
+            //     throw new FailedToDecryptDashboardBeforeClient();
+            //   }
+            // });
+            // return {
+            //   found: dashboardResponse.body.found.map((foundDashboard) =>
+            //     DashboardRepository.embellishDashboardFromAPI(foundDashboard, permissions)
+            //   ),
+            //   not_found: dashboardResponse.body.not_found,
+            // };
+            // }
+            // throw new FailedToFetchDashboards(`Failed to fetch dashboards. Got status code ${dashboardResponse.status}.`);
         });
     }
     static embellishDashboardFromAPI(dashboard, permissions) {
@@ -106,11 +110,24 @@ class DashboardRepository {
     }
     fetchDashboardAccessTokens() {
         return __awaiter(this, void 0, void 0, function* () {
-            const vizzlyApi = this.vizzly.getVizzlyAPI();
-            const accessTokens = yield vizzlyApi.execute(vizzlyApi.buildFetchDashboardAccessTokensRequest());
+            let accessTokens;
+            if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
+                const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
+                accessTokens = yield vizzlyQueryEngineApi.execute(vizzlyQueryEngineApi.buildFetchDashboardAccessTokensRequest());
+            }
+            else {
+                const vizzlyApi = this.vizzly.getVizzlyAPI();
+                accessTokens = yield vizzlyApi.execute(vizzlyApi.buildFetchDashboardAccessTokensRequest());
+            }
             if (accessTokens.status === 200) {
+                const formattedPermissions = accessTokens.body.permissions.map(Permission_1.Permission.formatDashboardPermission);
                 return {
-                    permissions: accessTokens.body.permissions.map(Permission_1.Permission.formatDashboardPermission),
+                    dashboards: accessTokens.body.dashboards.map((dashboard) => {
+                        if (typeof dashboard.definition === 'string')
+                            throw new FailedToDecryptDashboardBeforeClient_1.FailedToDecryptDashboardBeforeClient();
+                        return DashboardRepository.embellishDashboardFromAPI(dashboard, formattedPermissions);
+                    }),
+                    permissions: formattedPermissions,
                 };
             }
             throw new FailedToFetchDashboardAccessTokens_1.FailedToFetchDashboardAccessTokens('Failed to fetch dashboard access tokens.');

package/dist/models/GlobalLibraryRepository.d.ts

@@ -9,10 +9,11 @@ export declare class GlobalLibraryRepository {
         permissions: GlobalLibraryPermission[];
     }>;
     fetchGlobalLibraries(): Promise<{
-        found: GlobalLibrary[];
-        not_found: string[];
+        global_libraries: GlobalLibrary[];
+        permissions: GlobalLibraryPermission[];
     }>;
     fetchGlobalLibraryAccessTokens(): Promise<{
+        global_libraries: GlobalLibrary[];
         permissions: GlobalLibraryPermission[];
     }>;
     updateGlobalLibrary(params: UpdateGlobalLibraryParams): Promise<Response<{

package/dist/models/GlobalLibraryRepository.js

@@ -13,7 +13,6 @@ exports.GlobalLibraryRepository = void 0;
 const lodash_1 = require("lodash");
 const Permission_1 = require("./Permission");
 const FailedToFetchGlobalLibraryAccessTokens_1 = require("../errors/FailedToFetchGlobalLibraryAccessTokens");
-const FailedToFetchGlobalLibraries_1 = require("../errors/FailedToFetchGlobalLibraries");
 class GlobalLibraryRepository {
     constructor(vizzly) {
         this.cachedPermissions = { permissions: [] };
@@ -33,31 +32,24 @@ class GlobalLibraryRepository {
     }
     fetchGlobalLibraries() {
         return __awaiter(this, void 0, void 0, function* () {
-            let globalLibraries;
+            // Now, we fetch the libraries and the access tokens from the access call.
+            return yield this.fetchGlobalLibraryAccessTokens();
+        });
+    }
+    fetchGlobalLibraryAccessTokens() {
+        return __awaiter(this, void 0, void 0, function* () {
             const vizzlyApi = this.vizzly.getVizzlyAPI();
-            const accessTokens = yield this.fetchGlobalLibraryAccessTokens();
+            let accessTokens;
             if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
                 const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
-                globalLibraries = yield vizzlyQueryEngineApi.fetchGlobalLibraries({
-                    globalLibraryAccessTokens: accessTokens.permissions.map((p) => p.token),
-                });
+                accessTokens = yield vizzlyQueryEngineApi.fetchGlobalLibraryAccessTokens();
             }
             else {
-                globalLibraries = yield vizzlyApi.fetchGlobalLibraries({
-                    globalLibraryAccessTokens: accessTokens.permissions.map((p) => p.token),
-                });
+                accessTokens = yield vizzlyApi.fetchGlobalLibraryAccessTokens();
             }
-            if (globalLibraries.status === 200)
-                return globalLibraries.body;
-            throw new FailedToFetchGlobalLibraries_1.FailedToFetchGlobalLibraries(`Failed to fetch global libraries. Got status ${globalLibraries.status}`);
-        });
-    }
-    fetchGlobalLibraryAccessTokens() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vizzlyApi = this.vizzly.getVizzlyAPI();
-            const accessTokens = yield vizzlyApi.execute(vizzlyApi.buildFetchGlobalLibraryAccessTokensRequest());
             if (accessTokens.status === 200) {
                 return {
+                    global_libraries: accessTokens.body.global_libraries,
                     permissions: accessTokens.body.permissions.map(Permission_1.Permission.formatGlobalLibraryPermission),
                 };
             }
@@ -78,7 +70,7 @@ class GlobalLibraryRepository {
     }
     getChildGlobalLibrariesByParentGlobalLibraryId(parentGlobalLibraryId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { found: globalLibraries } = yield this.fetchGlobalLibraries();
+            const { global_libraries: globalLibraries } = yield this.fetchGlobalLibraries();
             return GlobalLibraryRepository.mapParentToChildGlobalLibraries(globalLibraries)[parentGlobalLibraryId] || [];
         });
     }

package/dist/models/Permission.d.ts

@@ -1,4 +1,4 @@
-import { DashboardPermission, GlobalLibraryPermission } from '../types';
+import { DashboardPermission, GlobalLibraryPermission, GlobalLibraryPermissionFromAPI } from '../types';
 export declare class Permission {
     static formatDashboardPermission(permission: {
         dashboard_id: string;
@@ -6,10 +6,5 @@ export declare class Permission {
         token: string;
         scope: 'read' | 'read_write';
     }): DashboardPermission;
-    static formatGlobalLibraryPermission(permission: {
-        global_library_id: string;
-        user_reference: string;
-        token: string;
-        scope: 'read' | 'read_write';
-    }): GlobalLibraryPermission;
+    static formatGlobalLibraryPermission(permission: GlobalLibraryPermissionFromAPI): GlobalLibraryPermission;
 }

package/dist/models/VizzlyApi.d.ts

@@ -1,6 +1,6 @@
 import { Api } from './Api';
 import { Authentication } from './Authentication';
-import { CreateDashboardParams, CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermission, Request, UpdateDashboardParams, UpdateGlobalLibraryParams } from '../types';
+import { CreateDashboardParams, CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermission, GlobalLibraryPermissionFromAPI, Request, UpdateDashboardParams, UpdateDashboardResponseBody, UpdateGlobalLibraryParams } from '../types';
 import { nVizzlyApi } from '../types';
 export declare class VizzlyApi extends Api {
     constructor(auth: Authentication, host?: string);
@@ -19,6 +19,10 @@ export declare class VizzlyApi extends Api {
     }): Request<{
         globalLibraryAccessTokens: string[];
     }>;
+    fetchGlobalLibraryAccessTokens(): Promise<import("../types").Response<{
+        global_libraries: GlobalLibrary[];
+        permissions: Array<GlobalLibraryPermissionFromAPI>;
+    }>>;
     buildFetchGlobalLibraryAccessTokensRequest(): Request<{
         projectAdminOverrideToken: string | undefined;
         dashboardAccessToken: string;
@@ -70,7 +74,7 @@ export declare class VizzlyApi extends Api {
     buildSaveEncryptedProjectEncryptionSecretRequest(params: nVizzlyApi.SaveEncryptedProjectEncryptionSecretParams): Request<{}>;
     saveScheduledReport(params: nVizzlyApi.SaveScheduledReportParams): Promise<import("../types").Response<unknown>>;
     buildSaveScheduledReportRequest(params: nVizzlyApi.SaveScheduledReportParams): Request<{}>;
-    updateDashboard(params: UpdateDashboardParams): Promise<import("../types").Response<unknown>>;
+    updateDashboard(params: UpdateDashboardParams): Promise<import("../types").Response<UpdateDashboardResponseBody>>;
     buildUpdateDashboardRequest(params: UpdateDashboardParams): Request<{}>;
     updateParentGlobalLibrary(params: nVizzlyApi.UpdateParentGlobalLibraryParams): Promise<import("../types").Response<unknown>>;
     buildUpdateParentGlobalLibraryRequest(params: nVizzlyApi.UpdateParentGlobalLibraryParams): Request<{}>;

package/dist/models/VizzlyApi.js

@@ -40,6 +40,11 @@ class VizzlyApi extends Api_1.Api {
             },
         };
     }
+    fetchGlobalLibraryAccessTokens() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildFetchGlobalLibraryAccessTokensRequest());
+        });
+    }
     buildFetchGlobalLibraryAccessTokensRequest() {
         return {
             path: '/api/v2/auth/global-library/access',

package/dist/models/VizzlyQueryEngineApi.d.ts

@@ -1,11 +1,23 @@
 import { Api } from './Api';
 import { Authentication } from './Authentication';
-import { nVizzlyQueryEngine, Request, extraHeaders, CreateDashboardParams, UpdateDashboardParams, UpdateGlobalLibraryParams, GlobalLibrary, CreateGlobalLibraryParams, GlobalLibraryPermission } from '../types';
+import { nVizzlyQueryEngine, Request, extraHeaders, CreateDashboardParams, UpdateDashboardParams, UpdateGlobalLibraryParams, GlobalLibrary, CreateGlobalLibraryParams, GlobalLibraryPermission, GlobalLibraryPermissionFromAPI } from '../types';
 export declare class VizzlyQueryEngineApi extends Api {
     constructor(auth: Authentication, host: string, extraHeaders?: extraHeaders);
     buildCreateDashboardRequest(params: CreateDashboardParams): Request<CreateDashboardParams & {
         dashboardAccessToken: string;
     }>;
+    buildFetchDashboardAccessTokensRequest(): Request<{
+        projectAdminOverrideToken: string | undefined;
+        dashboardAccessToken: string;
+    }>;
+    fetchGlobalLibraryAccessTokens(): Promise<import("../types").Response<{
+        global_libraries: GlobalLibrary[];
+        permissions: Array<GlobalLibraryPermissionFromAPI>;
+    }>>;
+    buildFetchGlobalLibraryAccessTokensRequest(): Request<{
+        projectAdminOverrideToken: string | undefined;
+        dashboardAccessToken: string;
+    }>;
     buildFetchDashboardsRequest(dashboardSessionAccessTokens: string[]): Request<{}>;
     createConfigFromUpload(createConfigFromUploadParams: nVizzlyQueryEngine.CreateConfigFromUploadParams): Promise<import("../types").Response<unknown>>;
     private buildCreateConfigFromUploadRequest;

package/dist/models/VizzlyQueryEngineApi.js

@@ -32,6 +32,31 @@ class VizzlyQueryEngineApi extends Api_1.Api {
             },
         };
     }
+    buildFetchDashboardAccessTokensRequest() {
+        return {
+            path: '/api/v1/dashboard/access',
+            method: 'post',
+            body: {
+                dashboardAccessToken: this.auth.getDashboardAccessToken(),
+                projectAdminOverrideToken: this.auth.getProjectAdminOverrideToken(),
+            },
+        };
+    }
+    fetchGlobalLibraryAccessTokens() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildFetchGlobalLibraryAccessTokensRequest());
+        });
+    }
+    buildFetchGlobalLibraryAccessTokensRequest() {
+        return {
+            path: '/api/v1/global-library/access',
+            method: 'post',
+            body: {
+                dashboardAccessToken: this.auth.getDashboardAccessToken(),
+                projectAdminOverrideToken: this.auth.getProjectAdminOverrideToken(),
+            },
+        };
+    }
     buildFetchDashboardsRequest(dashboardSessionAccessTokens) {
         return {
             path: '/api/v1/get-dashboards',
@@ -323,7 +348,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
             body: {
                 dashboardSessionToken: params.dashboardPermission.token,
                 definition: params.definition,
-                meta: params.meta,
+                meta: params.metadata || params.meta || {},
                 deleted: params.deleted,
             },
         };

package/dist/types.d.ts

@@ -1,9 +1,12 @@
 import { VizzlyQueryEngineApi } from './models/VizzlyQueryEngineApi';
 import { VizzlyApi } from './models/VizzlyApi';
 import { VizzlyAppApi } from './models/VizzlyAppApi';
-import { DashboardDefinition } from './types/dashboard';
+import { DashboardDefinition, DashboardFromAPI } from './types/dashboard';
 export * from './types/dashboard';
 export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type UpdateDashboardResponseBody = {
+    dashboard: DashboardFromAPI;
+};
 export type Response<T> = {
     status: number;
     headers: Headers;
@@ -408,3 +411,15 @@ export type DashboardPermission = BasePermission & {
 export type GlobalLibraryPermission = BasePermission & {
     globalLibraryId: string;
 };
+export type DashboardPermissionFromAPI = {
+    dashboard_id: string;
+    token: string;
+    user_reference: string;
+    scope: 'read' | 'read_write';
+};
+export type GlobalLibraryPermissionFromAPI = {
+    global_library_id: string;
+    user_reference: string;
+    token: string;
+    scope: 'read' | 'read_write';
+};

package/package.json

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