@vizzly/api-client 0.0.8 → 0.0.10

package/dist/errors/FailedToUpdateDashboard.d.ts

@@ -0,0 +1,3 @@
+export declare class FailedToUpdateDashboard extends Error {
+    constructor(message: string);
+}

package/dist/errors/FailedToUpdateDashboard.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailedToUpdateDashboard = void 0;
+class FailedToUpdateDashboard extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FailedToUpdateDashboard';
+    }
+}
+exports.FailedToUpdateDashboard = FailedToUpdateDashboard;

package/dist/errors/index.d.ts

@@ -10,3 +10,4 @@ export * from './FailedToSetupProject';
 export * from './FailedToResolveDataSets';
 export * from './FailedToCreateGlobalLibrary';
 export * from './FailedToDecryptDashboardBeforeClient';
+export * from './FailedToUpdateDashboard';

package/dist/errors/index.js

@@ -26,3 +26,4 @@ __exportStar(require("./FailedToSetupProject"), exports);
 __exportStar(require("./FailedToResolveDataSets"), exports);
 __exportStar(require("./FailedToCreateGlobalLibrary"), exports);
 __exportStar(require("./FailedToDecryptDashboardBeforeClient"), exports);
+__exportStar(require("./FailedToUpdateDashboard"), exports);

package/dist/models/DashboardManager.d.ts

@@ -1,16 +1,16 @@
 import { Vizzly } from './Vizzly';
-import { CreateDashboardParams, DashboardDefinition, Dashboard as DashboardType, GlobalLibrary, UpdateDashboardParams } from '../types';
+import { CreateDashboardParams, Dashboard, DashboardDefinition, Dashboard as DashboardType, GlobalLibrary, UpdateDashboardParams } from '../types';
 export declare class DashboardManager {
     private vizzly;
     constructor(vizzly: Vizzly);
     create(params: CreateDashboardParams): Promise<{
-        dashboard: DashboardType;
+        dashboard: Dashboard;
         permissions: import("../types").DashboardPermission[];
     }>;
-    update(params: Omit<UpdateDashboardParams, 'dashboardSessionToken' | 'definition'> & {
+    update(params: Omit<UpdateDashboardParams, 'dashboardPermission' | 'definition'> & {
         dashboardId: string;
         definition?: DashboardDefinition;
-    }): Promise<void>;
+    }): Promise<Dashboard>;
     getDashboards(): Promise<DashboardType[]>;
     static mergeDashboardsAndGlobalLibraries(dashboards: DashboardType[], globalLibraries: GlobalLibrary[]): DashboardType[];
     static mergeCustomFields(dashboard: DashboardType, dashboards: DashboardType[], parentGlobalLibrariesForDashboard: GlobalLibrary[], childGlobalLibrariesForDashboard: GlobalLibrary[]): DashboardType['definition']['customFields'];

package/dist/models/DashboardManager.js

@@ -40,9 +40,7 @@ class DashboardManager {
             if (!updateDashboardToken)
                 throw new Error(`Failed to find update token for dashboard.`);
             // Send the update request.
-            const dashboardUpdatedResponse = yield dashboardRepository.updateDashboard(Object.assign(Object.assign({}, params), { dashboardSessionToken: updateDashboardToken === null || updateDashboardToken === void 0 ? void 0 : updateDashboardToken.token }));
-            if (dashboardUpdatedResponse.status != 200)
-                throw new Error('Failed to update dashboard.');
+            const updatedDashboard = yield dashboardRepository.updateDashboard(Object.assign(Object.assign({}, params), { dashboardPermission: updateDashboardToken }));
             // Build the views to store in the libraries
             let libraryViewsToSave = [];
             if ((_a = params.definition) === null || _a === void 0 ? void 0 : _a.componentLibrary) {
@@ -92,6 +90,7 @@ class DashboardManager {
                 }
             }));
             yield Promise.all(updatePromises);
+            return updatedDashboard;
         });
     }
     getDashboards() {

package/dist/models/DashboardRepository.d.ts

@@ -1,29 +1,21 @@
-import { CreateDashboardParams, Dashboard, Response, UpdateDashboardParams } from '../types';
+import { CreateDashboardParams, Dashboard, DashboardFromAPI, DashboardPermission, UpdateDashboardParams } from '../types';
 import { Vizzly } from './Vizzly';
-type CreateDashboardResponseBody = {
-    dashboard: Dashboard;
-    permissions: Array<{
-        dashboard_id: string;
-        scope: 'read' | 'read_write';
-        token: string;
-        user_reference: string;
-    }>;
-};
-type FetchDashboardsResponseBody = {
-    found: Dashboard[];
-    not_found: any[];
-};
 export declare class DashboardRepository {
     private vizzly;
     constructor(vizzly: Vizzly);
     createDashboard(createParams: CreateDashboardParams): Promise<{
         dashboard: Dashboard;
-        permissions: import("../types").DashboardPermission[];
+        permissions: DashboardPermission[];
+    }>;
+    updateDashboard(params: UpdateDashboardParams): Promise<Dashboard>;
+    fetchDashboards(): Promise<{
+        found: Dashboard[];
+        not_found: string[];
     }>;
-    updateDashboard(params: UpdateDashboardParams): Promise<Response<CreateDashboardResponseBody>>;
-    fetchDashboards(): Promise<FetchDashboardsResponseBody>;
+    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<{
-        permissions: import("../types").DashboardPermission[];
+        permissions: DashboardPermission[];
     }>;
 }
-export {};

package/dist/models/DashboardRepository.js

@@ -15,6 +15,7 @@ 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 {
     constructor(vizzly) {
@@ -32,9 +33,10 @@ class DashboardRepository {
                 builtDashboard = yield vizzlyApi.execute(vizzlyApi.buildCreateDashboardRequest(createParams));
             }
             if (builtDashboard.status === 200) {
+                const formattedPermissions = builtDashboard.body.permissions.map(Permission_1.Permission.formatDashboardPermission);
                 return {
-                    dashboard: builtDashboard.body.dashboard,
-                    permissions: builtDashboard.body.permissions.map(Permission_1.Permission.formatDashboardPermission),
+                    dashboard: DashboardRepository.embellishDashboardFromAPI(builtDashboard.body.dashboard, formattedPermissions),
+                    permissions: formattedPermissions,
                 };
             }
             if (builtDashboard.status === 422) {
@@ -57,7 +59,12 @@ class DashboardRepository {
                 const vizzlyApi = this.vizzly.getVizzlyAPI();
                 updatedDashboard = yield vizzlyApi.execute(vizzlyApi.buildUpdateDashboardRequest(params));
             }
-            return updatedDashboard;
+            if (updatedDashboard.status === 200) {
+                return DashboardRepository.embellishDashboardFromAPI(updatedDashboard.body.dashboard, [
+                    params.dashboardPermission,
+                ]);
+            }
+            throw new FailedToUpdateDashboard_1.FailedToUpdateDashboard(`Failed to update dashboard, got status ${updatedDashboard.status}`);
         });
     }
     fetchDashboards() {
@@ -78,11 +85,25 @@ class DashboardRepository {
                         throw new FailedToDecryptDashboardBeforeClient_1.FailedToDecryptDashboardBeforeClient();
                     }
                 });
-                return dashboardResponse.body;
+                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}.`);
         });
     }
+    static embellishDashboardFromAPI(dashboard, permissions) {
+        return Object.assign(Object.assign({}, dashboard), { permission: DashboardRepository.takeHighestPermission(dashboard.id, permissions) });
+    }
+    static takeHighestPermission(dashboardId, permissions) {
+        const readPermissions = DashboardRepository.takePermissionsOfScope(dashboardId, permissions, 'read');
+        const readWritePermissions = DashboardRepository.takePermissionsOfScope(dashboardId, permissions, 'read_write');
+        return readWritePermissions[0] || readPermissions[0];
+    }
+    static takePermissionsOfScope(dashboardId, permissions, scope) {
+        return permissions.filter((p) => p.dashboardId === dashboardId && p.scope === scope);
+    }
     fetchDashboardAccessTokens() {
         return __awaiter(this, void 0, void 0, function* () {
             const vizzlyApi = this.vizzly.getVizzlyAPI();

package/dist/models/VizzlyApi.js

@@ -360,7 +360,7 @@ class VizzlyApi extends Api_1.Api {
             path: '/api/v2/dashboard',
             method: 'put',
             body: {
-                dashboardSessionToken: params.dashboardSessionToken,
+                dashboardSessionToken: params.dashboardPermission.token,
                 definition: params.definition,
                 meta: params.metadata || params.meta || {},
                 deleted: params.deleted,

package/dist/models/VizzlyQueryEngineApi.js

@@ -321,7 +321,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
             path: `/api/v1/dashboard`,
             method: 'put',
             body: {
-                dashboardSessionToken: params.dashboardSessionToken,
+                dashboardSessionToken: params.dashboardPermission.token,
                 definition: params.definition,
                 meta: params.meta,
                 deleted: params.deleted,

package/dist/types/dashboard.d.ts

@@ -1,4 +1,5 @@
-export type Dashboard = {
+import { DashboardPermission } from '../types';
+export type DashboardFromAPI = {
     definition: DashboardDefinition;
     created_at: string;
     id: string;
@@ -8,6 +9,12 @@ export type Dashboard = {
     updated_at: string;
     webhook_id: string | null;
 };
+export type Dashboard = DashboardFromAPI & {
+    /**
+     * Highest permission token for the dashboard.
+     */
+    permission: DashboardPermission;
+};
 export type DashboardDefinition = {
     display: any;
     componentLibrary: Array<{

package/dist/types.d.ts

@@ -43,7 +43,7 @@ export type CreateDashboardParamsUnencrypted = Omit<CreateDashboardParams, 'defi
     definition: DashboardDefinition;
 };
 export type UpdateDashboardParams = {
-    dashboardSessionToken: string;
+    dashboardPermission: DashboardPermission;
     definition?: DashboardDefinition | string;
     /** @deprecated - use `metadata` instead */
     meta?: any;

package/package.json

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