@vizzly/api-client 0.0.2 → 0.0.4

package/dist/models/{Dashboard.d.ts → DashboardManager.d.ts}

@@ -1,17 +1,11 @@
 import { Vizzly } from './Vizzly';
 import { CreateDashboardParams, DashboardDefinition, Dashboard as DashboardType, GlobalLibrary, UpdateDashboardParams } from '../types';
-export declare class Dashboard {
+export declare class DashboardManager {
     private vizzly;
     constructor(vizzly: Vizzly);
     create(params: CreateDashboardParams): Promise<{
         dashboard: DashboardType;
-        permissions: ({
-            userReference: string;
-            token: string;
-            scope: "read" | "read_write";
-        } & {
-            dashboardId: string;
-        })[];
+        permissions: import("../types").DashboardPermission[];
     }>;
     update(params: Omit<UpdateDashboardParams, 'dashboardSessionToken' | 'definition'> & {
         dashboardId: string;

package/dist/models/{Dashboard.js → DashboardManager.js}

@@ -9,10 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dashboard = void 0;
+exports.DashboardManager = void 0;
 const lodash_1 = require("lodash");
 const GlobalLibraryRepository_1 = require("./GlobalLibraryRepository");
-class Dashboard {
+class DashboardManager {
     constructor(vizzly) {
         this.vizzly = vizzly;
     }
@@ -102,7 +102,7 @@ class Dashboard {
             const libraryRepo = this.vizzly.getGlobalLibraryRepository();
             const { found: dashboards } = yield dashboardRepo.fetchDashboards();
             const { found: globalLibraries } = yield libraryRepo.fetchGlobalLibraries();
-            return Dashboard.mergeDashboardsAndGlobalLibraries(dashboards, globalLibraries);
+            return DashboardManager.mergeDashboardsAndGlobalLibraries(dashboards, globalLibraries);
         });
     }
     static mergeDashboardsAndGlobalLibraries(dashboards, globalLibraries) {
@@ -120,15 +120,15 @@ class Dashboard {
             // Add the views from the various sources together. The order does matter -
             // first elements are kept if a duplicate view is found.
             let newLibrary = (0, lodash_1.uniqBy)([
-                ...Dashboard.markViewsAsProtected(parentGlobalLibraries.flatMap((gL) => gL.library.views || [])),
+                ...DashboardManager.markViewsAsProtected(parentGlobalLibraries.flatMap((gL) => gL.library.views || [])),
                 ...childGlobalLibraries.flatMap((gL) => gL.library.views || []),
-                ...Dashboard.markViewsAsProtected(parentDashboardComponentLibrary),
+                ...DashboardManager.markViewsAsProtected(parentDashboardComponentLibrary),
                 ...(dashboard.parent_dashboard_id === null
-                    ? Dashboard.markViewsAsProtected(dashboardComponentLibrary)
+                    ? DashboardManager.markViewsAsProtected(dashboardComponentLibrary)
                     : dashboardComponentLibrary || []),
             ], (view) => view.attributes.viewId);
             dashboard.definition.componentLibrary = newLibrary;
-            dashboard.definition.customFields = Dashboard.mergeCustomFields(dashboard, dashboards, parentGlobalLibraries, childGlobalLibraries);
+            dashboard.definition.customFields = DashboardManager.mergeCustomFields(dashboard, dashboards, parentGlobalLibraries, childGlobalLibraries);
             return dashboard;
         });
     }
@@ -153,4 +153,4 @@ class Dashboard {
         return componentLibrary.map((view) => (Object.assign(Object.assign({}, view), { attributes: Object.assign(Object.assign({}, view.attributes), { protectedByOrganisation: true }) })));
     }
 }
-exports.Dashboard = Dashboard;
+exports.DashboardManager = DashboardManager;

package/dist/models/DashboardRepository.d.ts

@@ -18,24 +18,12 @@ export declare class DashboardRepository {
     constructor(vizzly: Vizzly);
     createDashboard(createParams: CreateDashboardParams): Promise<{
         dashboard: Dashboard;
-        permissions: ({
-            userReference: string;
-            token: string;
-            scope: "read" | "read_write";
-        } & {
-            dashboardId: string;
-        })[];
+        permissions: import("../types").DashboardPermission[];
     }>;
     updateDashboard(params: UpdateDashboardParams): Promise<Response<CreateDashboardResponseBody>>;
     fetchDashboards(): Promise<FetchDashboardsResponseBody>;
     fetchDashboardAccessTokens(): Promise<{
-        permissions: ({
-            userReference: string;
-            token: string;
-            scope: "read" | "read_write";
-        } & {
-            dashboardId: string;
-        })[];
+        permissions: import("../types").DashboardPermission[];
     }>;
 }
 export {};

package/dist/models/GlobalLibraryRepository.d.ts

@@ -1,23 +1,18 @@
-import { GlobalLibrary, UpdateGlobalLibraryParams, nVizzlyApi } from '../types';
+import { GlobalLibrary, GlobalLibraryPermission, UpdateGlobalLibraryParams, nVizzlyApi } from '../types';
 import { Vizzly } from './Vizzly';
 export declare class GlobalLibraryRepository {
     private vizzly;
+    private cachedPermissions;
     constructor(vizzly: Vizzly);
     createGlobalLibrary(createParams: nVizzlyApi.CreateGlobalLibraryParams): Promise<import("../types").Response<{
         global_library: GlobalLibrary;
-        permissions: import("../types").GlobalLibraryPermission[];
+        permissions: GlobalLibraryPermission[];
     }>>;
     fetchGlobalLibraries(): Promise<{
         found: GlobalLibrary[];
     }>;
     fetchGlobalLibraryAccessTokens(): Promise<{
-        permissions: ({
-            userReference: string;
-            token: string;
-            scope: "read" | "read_write";
-        } & {
-            globalLibraryId: string;
-        })[];
+        permissions: GlobalLibraryPermission[];
     }>;
     updateGlobalLibrary(params: UpdateGlobalLibraryParams): Promise<import("../types").Response<unknown>>;
     getChildGlobalLibrariesByParentGlobalLibraryId(parentGlobalLibraryId: string): Promise<GlobalLibrary[]>;

package/dist/models/GlobalLibraryRepository.js

@@ -16,6 +16,7 @@ const FailedToFetchGlobalLibraryAccessTokens_1 = require("../errors/FailedToFetc
 const FailedToFetchGlobalLibraries_1 = require("../errors/FailedToFetchGlobalLibraries");
 class GlobalLibraryRepository {
     constructor(vizzly) {
+        this.cachedPermissions = { permissions: [] };
         this.vizzly = vizzly;
     }
     createGlobalLibrary(createParams) {
@@ -37,13 +38,6 @@ class GlobalLibraryRepository {
             throw new FailedToFetchGlobalLibraries_1.FailedToFetchGlobalLibraries(`Failed to fetch global libraries. Got status ${globalLibraries.status}`);
         });
     }
-    // async updateGlobalLibrary(params: {}) {
-    // const vizzlyApi = this.vizzly.getVizzlyAPI();
-    // const accessTokens = await vizzlyApi.execute<{
-    //   permissions: Array<{ global_library_id: string; token: string; user_reference: string, scope: 'read' | 'read_write' }>;
-    // }>(vizzlyApi.());
-    // return accessTokens;
-    // }
     fetchGlobalLibraryAccessTokens() {
         return __awaiter(this, void 0, void 0, function* () {
             const vizzlyApi = this.vizzly.getVizzlyAPI();

package/dist/models/Permission.d.ts

@@ -1,14 +1,4 @@
-type BasePermission = {
-    userReference: string;
-    token: string;
-    scope: 'read' | 'read_write';
-};
-type DashboardPermission = BasePermission & {
-    dashboardId: string;
-};
-type GlobalLibraryPermission = BasePermission & {
-    globalLibraryId: string;
-};
+import { DashboardPermission, GlobalLibraryPermission } from '../types';
 export declare class Permission {
     static formatDashboardPermission(permission: {
         dashboard_id: string;
@@ -23,4 +13,3 @@ export declare class Permission {
         scope: 'read' | 'read_write';
     }): GlobalLibraryPermission;
 }
-export {};

package/dist/models/Vizzly.d.ts

@@ -2,10 +2,13 @@ import { APIs, PartialBy } from '../types';
 import { ImplementationStrategy, PersistDirectToVizzlyApi } from './ImplementationStrategy';
 import { DashboardRepository } from './DashboardRepository';
 import { GlobalLibraryRepository } from './GlobalLibraryRepository';
-import { Dashboard } from './Dashboard';
+import { DashboardManager } from './DashboardManager';
 export declare class Vizzly {
     private APIs;
     implementationStrategy: ImplementationStrategy;
+    private dashboardRepository;
+    private globalLibraryRepository;
+    private dashboardManager;
     constructor(APIs: PartialBy<APIs, 'vizzlyQueryEngineApi'>, implementationStrategy: PersistDirectToVizzlyApi);
     getAPIs(): APIs | PartialBy<APIs, 'vizzlyQueryEngineApi'>;
     getVizzlyAppApi(): import("./VizzlyAppApi").VizzlyAppApi;
@@ -13,5 +16,5 @@ export declare class Vizzly {
     getVizzlyAPI(): import("./VizzlyApi").VizzlyApi;
     getDashboardRepository(): DashboardRepository;
     getGlobalLibraryRepository(): GlobalLibraryRepository;
-    getDashboard(): Dashboard;
+    getDashboardManager(): DashboardManager;
 }

package/dist/models/Vizzly.js

@@ -4,11 +4,14 @@ exports.Vizzly = void 0;
 const MissingRequiredVizzlyQueryEngineApi_1 = require("../errors/MissingRequiredVizzlyQueryEngineApi");
 const DashboardRepository_1 = require("./DashboardRepository");
 const GlobalLibraryRepository_1 = require("./GlobalLibraryRepository");
-const Dashboard_1 = require("./Dashboard");
+const DashboardManager_1 = require("./DashboardManager");
 class Vizzly {
     constructor(APIs, implementationStrategy) {
         this.APIs = APIs;
         this.implementationStrategy = implementationStrategy;
+        this.dashboardManager = new DashboardManager_1.DashboardManager(this);
+        this.dashboardRepository = new DashboardRepository_1.DashboardRepository(this);
+        this.globalLibraryRepository = new GlobalLibraryRepository_1.GlobalLibraryRepository(this);
     }
     getAPIs() {
         if (this.implementationStrategy.shouldPersistViaQueryEngine() && !this.APIs.vizzlyQueryEngineApi) {
@@ -26,14 +29,13 @@ class Vizzly {
         return this.getAPIs().vizzlyApi;
     }
     getDashboardRepository() {
-        return new DashboardRepository_1.DashboardRepository(this);
+        return this.dashboardRepository;
     }
     getGlobalLibraryRepository() {
-        return new GlobalLibraryRepository_1.GlobalLibraryRepository(this);
+        return this.globalLibraryRepository;
     }
-    // TODO; what should this be called!?
-    getDashboard() {
-        return new Dashboard_1.Dashboard(this);
+    getDashboardManager() {
+        return this.dashboardManager;
     }
 }
 exports.Vizzly = Vizzly;

package/dist/types.d.ts

@@ -397,9 +397,14 @@ export type GlobalLibrary = {
     parent_global_library_id: string | null;
     updated_at: string;
 };
-export type GlobalLibraryPermission = {
-    global_library_id: string;
-    scope: 'read_write' | 'read';
+type BasePermission = {
+    userReference: string;
     token: string;
-    user_reference: string;
+    scope: 'read' | 'read_write';
+};
+export type DashboardPermission = BasePermission & {
+    dashboardId: string;
+};
+export type GlobalLibraryPermission = BasePermission & {
+    globalLibraryId: string;
 };

package/package.json

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