@vizzly/api-client 0.0.1

package/dist/models/Dashboard.js

@@ -0,0 +1,156 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dashboard = void 0;
+const lodash_1 = require("lodash");
+const GlobalLibraryRepository_1 = require("./GlobalLibraryRepository");
+class Dashboard {
+    constructor(vizzly) {
+        this.vizzly = vizzly;
+    }
+    create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dashboardRepository = this.vizzly.getDashboardRepository();
+            return yield dashboardRepository.createDashboard(params);
+        });
+    }
+    update(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 dashboardToUpdate = dashboards.find((dashboard) => dashboard.id === params.dashboardId);
+            if (!dashboardToUpdate)
+                throw new Error('Cannot find dashboard to update.');
+            const { parentGlobalLibraries, childGlobalLibraries } = GlobalLibraryRepository_1.GlobalLibraryRepository.splitParentAndChildGlobalLibraries(globalLibraries);
+            // Get the token to update the dashboard.
+            const updateDashboardToken = dashboardPermissions.find((permission) => permission.scope === 'read_write' && permission.dashboardId === params.dashboardId);
+            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.');
+            // Build the views to store in the libraries
+            let libraryViewsToSave = [];
+            if ((_a = params.definition) === null || _a === void 0 ? void 0 : _a.componentLibrary) {
+                libraryViewsToSave = (0, lodash_1.cloneDeep)(params.definition.componentLibrary || []).filter((c) => {
+                    const isParentDashboard = dashboardToUpdate.parent_dashboard_id === null;
+                    if (isParentDashboard) {
+                        // All content of the library are for the parent library, if the parent dashboard
+                        // is being edited.
+                        return true;
+                    }
+                    else {
+                        return !c.attributes.protectedByOrganisation;
+                    }
+                });
+            }
+            const librariesToUpdate = dashboardToUpdate.parent_dashboard_id === null ? parentGlobalLibraries : childGlobalLibraries;
+            // If it's not a parent dashboard, and there are views or custom fields to save, but there are no libraries
+            // then create one first.
+            const isParent = dashboardToUpdate.parent_dashboard_id === null;
+            const hasThingsToSaveInLibrary = libraryViewsToSave.length > 0 || !!((_b = params.definition) === null || _b === void 0 ? void 0 : _b.customFields);
+            const parentGlobalLibrary = globalLibraries.find((gL) => gL.parent_global_library_id === null);
+            if (!isParent && parentGlobalLibrary && hasThingsToSaveInLibrary && librariesToUpdate.length === 0) {
+                const createdChildGlobalLibrary = yield globalLibraryRepository.createGlobalLibrary({
+                    library: {
+                        views: libraryViewsToSave,
+                        // No concept of being protected, so only option is to save them all
+                        customFields: ((_c = params.definition) === null || _c === void 0 ? void 0 : _c.customFields) || {},
+                    },
+                    parentGlobalLibraryId: parentGlobalLibrary.id,
+                    permissions: [{ scope: 'read_write' }],
+                });
+                if (createdChildGlobalLibrary.status != 200)
+                    throw new Error(`Failed to create first child library for user. ${createdChildGlobalLibrary.status}`);
+            }
+            const updatePromises = librariesToUpdate.map((gL) => __awaiter(this, void 0, void 0, function* () {
+                var _d;
+                const writePermission = globalLibraryPermissions.find((permission) => permission.globalLibraryId === gL.id && permission.scope === 'read_write');
+                if (!writePermission)
+                    console.log('No write permission');
+                if (writePermission) {
+                    yield globalLibraryRepository.updateGlobalLibrary({
+                        globalLibrarySessionToken: writePermission.token,
+                        library: {
+                            views: libraryViewsToSave,
+                            // No concept of being protected, so only option is to save them all
+                            customFields: ((_d = params.definition) === null || _d === void 0 ? void 0 : _d.customFields) || {},
+                        },
+                    });
+                }
+            }));
+            yield Promise.all(updatePromises);
+        });
+    }
+    getDashboards() {
+        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();
+            return Dashboard.mergeDashboardsAndGlobalLibraries(dashboards, globalLibraries);
+        });
+    }
+    static mergeDashboardsAndGlobalLibraries(dashboards, globalLibraries) {
+        return (0, lodash_1.cloneDeep)(dashboards).map((dashboard) => {
+            // Views attached directly to a library on the parent dashboard.
+            let dashboardComponentLibrary = (0, lodash_1.cloneDeep)(dashboard.definition.componentLibrary);
+            let parentDashboardComponentLibrary = dashboard.parent_dashboard_id === null
+                ? []
+                : dashboards.find((d) => d.id === dashboard.parent_dashboard_id).definition.componentLibrary;
+            let { parentGlobalLibraries, childGlobalLibraries } = GlobalLibraryRepository_1.GlobalLibraryRepository.splitParentAndChildGlobalLibraries(globalLibraries);
+            // Only include the child libraries if the dashboard is not a parent.
+            childGlobalLibraries = dashboard.parent_dashboard_id === null ? [] : childGlobalLibraries;
+            // If parent dashboard, all libraries are for the parent.
+            // parentGlobalLibraries = dashboard.parent_dashboard_id === null ? [...parentGlobalLibraries, ...childGlobalLibraries] : [];
+            // 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 || [])),
+                ...childGlobalLibraries.flatMap((gL) => gL.library.views || []),
+                ...Dashboard.markViewsAsProtected(parentDashboardComponentLibrary),
+                ...(dashboard.parent_dashboard_id === null
+                    ? Dashboard.markViewsAsProtected(dashboardComponentLibrary)
+                    : dashboardComponentLibrary || []),
+            ], (view) => view.attributes.viewId);
+            dashboard.definition.componentLibrary = newLibrary;
+            dashboard.definition.customFields = Dashboard.mergeCustomFields(dashboard, dashboards, parentGlobalLibraries, childGlobalLibraries);
+            return dashboard;
+        });
+    }
+    static mergeCustomFields(dashboard, dashboards, parentGlobalLibrariesForDashboard, childGlobalLibrariesForDashboard) {
+        var _a;
+        const maybeParentDashboardCustomFields = dashboard.parent_dashboard_id === null
+            ? {}
+            : ((_a = dashboards.find((d) => d.id === dashboard.parent_dashboard_id)) === null || _a === void 0 ? void 0 : _a.definition.customFields) || {};
+        const doMerge = (...toBeMerged) => {
+            return toBeMerged.reduce((customFields, acc) => {
+                Object.keys(customFields || {}).forEach((dataSetId) => {
+                    if (!acc[dataSetId])
+                        acc[dataSetId] = [];
+                    acc[dataSetId] = (0, lodash_1.uniqBy)([...acc[dataSetId], ...((customFields === null || customFields === void 0 ? void 0 : customFields[dataSetId]) || [])], (cF) => cF.id);
+                });
+                return acc;
+            }, {});
+        };
+        return doMerge((0, lodash_1.cloneDeep)(dashboard.definition.customFields) || {}, (0, lodash_1.cloneDeep)(maybeParentDashboardCustomFields) || {}, ...(0, lodash_1.cloneDeep)(childGlobalLibrariesForDashboard).map((p) => p.library.customFields || {}), ...(0, lodash_1.cloneDeep)(parentGlobalLibrariesForDashboard).map((p) => p.library.customFields || {}));
+    }
+    static markViewsAsProtected(componentLibrary) {
+        return componentLibrary.map((view) => (Object.assign(Object.assign({}, view), { attributes: Object.assign(Object.assign({}, view.attributes), { protectedByOrganisation: true }) })));
+    }
+}
+exports.Dashboard = Dashboard;

package/dist/models/DashboardRepository.d.ts

@@ -0,0 +1,41 @@
+import { CreateDashboardParams, Dashboard, Response, 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: ({
+            userReference: string;
+            token: string;
+            scope: "read" | "read_write";
+        } & {
+            dashboardId: string;
+        })[];
+    }>;
+    updateDashboard(params: UpdateDashboardParams): Promise<Response<CreateDashboardResponseBody>>;
+    fetchDashboards(): Promise<FetchDashboardsResponseBody>;
+    fetchDashboardAccessTokens(): Promise<{
+        permissions: ({
+            userReference: string;
+            token: string;
+            scope: "read" | "read_write";
+        } & {
+            dashboardId: string;
+        })[];
+    }>;
+}
+export {};

package/dist/models/DashboardRepository.js

@@ -0,0 +1,92 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardRepository = void 0;
+const DashboardQuotaReached_1 = require("../errors/DashboardQuotaReached");
+const FailedToCreateDashboard_1 = require("../errors/FailedToCreateDashboard");
+const FailedToFetchDashboardAccessTokens_1 = require("../errors/FailedToFetchDashboardAccessTokens");
+const FailedToFetchDashboards_1 = require("../errors/FailedToFetchDashboards");
+const Permission_1 = require("./Permission");
+class DashboardRepository {
+    constructor(vizzly) {
+        this.vizzly = vizzly;
+    }
+    createDashboard(createParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let builtDashboard;
+            if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
+                const queryEngineAPI = this.vizzly.getVizzlyQueryEngineAPI();
+                builtDashboard = yield queryEngineAPI.execute(queryEngineAPI.buildCreateDashboardRequest(createParams));
+            }
+            else {
+                const vizzlyApi = this.vizzly.getVizzlyAPI();
+                builtDashboard = yield vizzlyApi.execute(vizzlyApi.buildCreateDashboardRequest(createParams));
+            }
+            if (builtDashboard.status === 200) {
+                return {
+                    dashboard: builtDashboard.body.dashboard,
+                    permissions: builtDashboard.body.permissions.map(Permission_1.Permission.formatDashboardPermission),
+                };
+            }
+            if (builtDashboard.status === 422) {
+                throw new DashboardQuotaReached_1.DashboardQuotaReached(`Dashboard quota reached; ${JSON.stringify(builtDashboard.body)}`);
+            }
+            if (builtDashboard.status != 200) {
+                throw new FailedToCreateDashboard_1.FailedToCreateDashboard(`Failed to create the dashboard from POST /api/v2/dashboard. Got ${builtDashboard.status}`);
+            }
+            throw new FailedToCreateDashboard_1.FailedToCreateDashboard(`Unknown failure. Got status ${builtDashboard.status}`);
+        });
+    }
+    updateDashboard(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let updatedDashboard;
+            if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
+                const queryEngineAPI = this.vizzly.getVizzlyQueryEngineAPI();
+                updatedDashboard = yield queryEngineAPI.execute(queryEngineAPI.buildUpdateDashboardRequest(params));
+            }
+            else {
+                const vizzlyApi = this.vizzly.getVizzlyAPI();
+                updatedDashboard = yield vizzlyApi.execute(vizzlyApi.buildUpdateDashboardRequest(params));
+            }
+            return updatedDashboard;
+        });
+    }
+    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)
+                return dashboardResponse.body;
+            throw new FailedToFetchDashboards_1.FailedToFetchDashboards(`Failed to fetch dashboards. Got status code ${dashboardResponse.status}.`);
+        });
+    }
+    fetchDashboardAccessTokens() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vizzlyApi = this.vizzly.getVizzlyAPI();
+            const accessTokens = yield vizzlyApi.execute(vizzlyApi.buildFetchDashboardAccessTokensRequest());
+            if (accessTokens.status === 200) {
+                return {
+                    permissions: accessTokens.body.permissions.map(Permission_1.Permission.formatDashboardPermission),
+                };
+            }
+            throw new FailedToFetchDashboardAccessTokens_1.FailedToFetchDashboardAccessTokens('Failed to fetch dashboard access tokens.');
+        });
+    }
+}
+exports.DashboardRepository = DashboardRepository;

package/dist/models/GlobalLibraryRepository.d.ts

@@ -0,0 +1,35 @@
+import { GlobalLibrary, UpdateGlobalLibraryParams, nVizzlyApi } from '../types';
+import { Vizzly } from './Vizzly';
+export declare class GlobalLibraryRepository {
+    private vizzly;
+    constructor(vizzly: Vizzly);
+    createGlobalLibrary(createParams: nVizzlyApi.CreateGlobalLibraryParams): Promise<import("../types").Response<{
+        global_library: GlobalLibrary;
+        permissions: import("../types").GlobalLibraryPermission[];
+    }>>;
+    fetchGlobalLibraries(): Promise<{
+        found: GlobalLibrary[];
+    }>;
+    fetchGlobalLibraryAccessTokens(): Promise<{
+        permissions: ({
+            userReference: string;
+            token: string;
+            scope: "read" | "read_write";
+        } & {
+            globalLibraryId: string;
+        })[];
+    }>;
+    updateGlobalLibrary(params: UpdateGlobalLibraryParams): Promise<import("../types").Response<unknown>>;
+    getChildGlobalLibrariesByParentGlobalLibraryId(parentGlobalLibraryId: string): Promise<GlobalLibrary[]>;
+    static splitParentAndChildGlobalLibraries(globalLibraries: GlobalLibrary[]): {
+        childGlobalLibraries: GlobalLibrary[];
+        parentGlobalLibraries: GlobalLibrary[];
+    };
+    /**
+     * Takes a list of global libraries, and returns a mapping of parent global
+     * library to a list of it's children
+     */
+    static mapParentToChildGlobalLibraries(globalLibraries: GlobalLibrary[]): {
+        [parentGlobalLibraryId: string]: GlobalLibrary[];
+    };
+}

package/dist/models/GlobalLibraryRepository.js

@@ -0,0 +1,106 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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.vizzly = vizzly;
+    }
+    createGlobalLibrary(createParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vizzlyApi = this.vizzly.getVizzlyAPI();
+            const result = yield vizzlyApi.createGlobalLibrary(createParams);
+            return result;
+        });
+    }
+    fetchGlobalLibraries() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vizzlyApi = this.vizzly.getVizzlyAPI();
+            const accessTokens = yield this.fetchGlobalLibraryAccessTokens();
+            const globalLibraries = yield vizzlyApi.execute(vizzlyApi.buildFetchGlobalLibrariesRequest({
+                globalLibraryAccessTokens: accessTokens.permissions.map((p) => p.token),
+            }));
+            if (globalLibraries.status === 200)
+                return globalLibraries.body;
+            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();
+            const accessTokens = yield vizzlyApi.execute(vizzlyApi.buildFetchGlobalLibraryAccessTokensRequest());
+            if (accessTokens.status === 200) {
+                return {
+                    permissions: accessTokens.body.permissions.map(Permission_1.Permission.formatGlobalLibraryPermission),
+                };
+            }
+            throw new FailedToFetchGlobalLibraryAccessTokens_1.FailedToFetchGlobalLibraryAccessTokens('Failed to load access tokens for the global library.');
+        });
+    }
+    updateGlobalLibrary(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vizzlyApi = this.vizzly.getVizzlyAPI();
+            return yield vizzlyApi.updateGlobalLibrary(params);
+        });
+    }
+    getChildGlobalLibrariesByParentGlobalLibraryId(parentGlobalLibraryId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { found: globalLibraries } = yield this.fetchGlobalLibraries();
+            return GlobalLibraryRepository.mapParentToChildGlobalLibraries(globalLibraries)[parentGlobalLibraryId] || [];
+        });
+    }
+    static splitParentAndChildGlobalLibraries(globalLibraries) {
+        let childGlobalLibraries = [];
+        let parentGlobalLibraries = [];
+        globalLibraries.forEach((gL) => {
+            if (gL.parent_global_library_id === null) {
+                parentGlobalLibraries = [...parentGlobalLibraries, gL];
+            }
+            else {
+                childGlobalLibraries = [...childGlobalLibraries, gL];
+            }
+        });
+        return { childGlobalLibraries, parentGlobalLibraries };
+    }
+    /**
+     * Takes a list of global libraries, and returns a mapping of parent global
+     * library to a list of it's children
+     */
+    static mapParentToChildGlobalLibraries(globalLibraries) {
+        let mapping = {};
+        (0, lodash_1.cloneDeep)(globalLibraries).forEach((globalLibrary) => {
+            if (globalLibrary.parent_global_library_id !== null) {
+                // Child library
+                // Ensure the parent has been setup
+                if (!mapping[globalLibrary.parent_global_library_id])
+                    mapping[globalLibrary.parent_global_library_id] = [];
+                // Add the child to the parent's list of children
+                mapping[globalLibrary.parent_global_library_id] = [
+                    ...mapping[globalLibrary.parent_global_library_id],
+                    globalLibrary,
+                ];
+            }
+        });
+        return mapping;
+    }
+}
+exports.GlobalLibraryRepository = GlobalLibraryRepository;

package/dist/models/ImplementationStrategy.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class ImplementationStrategy {
+    abstract shouldPersistViaQueryEngine(): boolean;
+}
+export declare class PersistViaQueryEngine extends ImplementationStrategy {
+    shouldPersistViaQueryEngine(): boolean;
+}
+export declare class PersistDirectToVizzlyApi extends ImplementationStrategy {
+    shouldPersistViaQueryEngine(): boolean;
+}

package/dist/models/ImplementationStrategy.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistDirectToVizzlyApi = exports.PersistViaQueryEngine = exports.ImplementationStrategy = void 0;
+class ImplementationStrategy {
+}
+exports.ImplementationStrategy = ImplementationStrategy;
+class PersistViaQueryEngine extends ImplementationStrategy {
+    shouldPersistViaQueryEngine() {
+        return true;
+    }
+}
+exports.PersistViaQueryEngine = PersistViaQueryEngine;
+class PersistDirectToVizzlyApi extends ImplementationStrategy {
+    shouldPersistViaQueryEngine() {
+        return false;
+    }
+}
+exports.PersistDirectToVizzlyApi = PersistDirectToVizzlyApi;

package/dist/models/Permission.d.ts

@@ -0,0 +1,26 @@
+type BasePermission = {
+    userReference: string;
+    token: string;
+    scope: 'read' | 'read_write';
+};
+type DashboardPermission = BasePermission & {
+    dashboardId: string;
+};
+type GlobalLibraryPermission = BasePermission & {
+    globalLibraryId: string;
+};
+export declare class Permission {
+    static formatDashboardPermission(permission: {
+        dashboard_id: string;
+        user_reference: string;
+        token: string;
+        scope: 'read' | 'read_write';
+    }): DashboardPermission;
+    static formatGlobalLibraryPermission(permission: {
+        global_library_id: string;
+        user_reference: string;
+        token: string;
+        scope: 'read' | 'read_write';
+    }): GlobalLibraryPermission;
+}
+export {};

package/dist/models/Permission.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Permission = void 0;
+class Permission {
+    static formatDashboardPermission(permission) {
+        return {
+            userReference: permission.user_reference,
+            scope: permission.scope,
+            token: permission.token,
+            dashboardId: permission.dashboard_id,
+        };
+    }
+    static formatGlobalLibraryPermission(permission) {
+        return {
+            userReference: permission.user_reference,
+            scope: permission.scope,
+            token: permission.token,
+            globalLibraryId: permission.global_library_id,
+        };
+    }
+}
+exports.Permission = Permission;

package/dist/models/Vizzly.d.ts

@@ -0,0 +1,17 @@
+import { APIs, PartialBy } from '../types';
+import { ImplementationStrategy, PersistDirectToVizzlyApi } from './ImplementationStrategy';
+import { DashboardRepository } from './DashboardRepository';
+import { GlobalLibraryRepository } from './GlobalLibraryRepository';
+import { Dashboard } from './Dashboard';
+export declare class Vizzly {
+    private APIs;
+    implementationStrategy: ImplementationStrategy;
+    constructor(APIs: PartialBy<APIs, 'vizzlyQueryEngineApi'>, implementationStrategy: PersistDirectToVizzlyApi);
+    getAPIs(): APIs | PartialBy<APIs, 'vizzlyQueryEngineApi'>;
+    getVizzlyAppApi(): import("./VizzlyAppApi").VizzlyAppApi;
+    getVizzlyQueryEngineAPI(): import("./VizzlyQueryEngineApi").VizzlyQueryEngineApi;
+    getVizzlyAPI(): import("./VizzlyApi").VizzlyApi;
+    getDashboardRepository(): DashboardRepository;
+    getGlobalLibraryRepository(): GlobalLibraryRepository;
+    getDashboard(): Dashboard;
+}

package/dist/models/Vizzly.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+class Vizzly {
+    constructor(APIs, implementationStrategy) {
+        this.APIs = APIs;
+        this.implementationStrategy = implementationStrategy;
+    }
+    getAPIs() {
+        if (this.implementationStrategy.shouldPersistViaQueryEngine() && !this.APIs.vizzlyQueryEngineApi) {
+            throw new MissingRequiredVizzlyQueryEngineApi_1.MissingRequiredVizzlyQueryEngineApi('Strategy is to persist via a query engine. However no query engine API was provided.');
+        }
+        return this.APIs;
+    }
+    getVizzlyAppApi() {
+        return this.getAPIs().vizzlyAppApi;
+    }
+    getVizzlyQueryEngineAPI() {
+        return this.getAPIs().vizzlyQueryEngineApi;
+    }
+    getVizzlyAPI() {
+        return this.getAPIs().vizzlyApi;
+    }
+    getDashboardRepository() {
+        return new DashboardRepository_1.DashboardRepository(this);
+    }
+    getGlobalLibraryRepository() {
+        return new GlobalLibraryRepository_1.GlobalLibraryRepository(this);
+    }
+    // TODO; what should this be called!?
+    getDashboard() {
+        return new Dashboard_1.Dashboard(this);
+    }
+}
+exports.Vizzly = Vizzly;

package/dist/models/VizzlyApi.d.ts

@@ -0,0 +1,77 @@
+import { Api } from './Api';
+import { Authentication } from './Authentication';
+import { CreateDashboardParams, GlobalLibrary, GlobalLibraryPermission, Request, UpdateDashboardParams, UpdateGlobalLibraryParams } from '../types';
+import { nVizzlyApi } from '../types';
+export declare class VizzlyApi extends Api {
+    constructor(auth: Authentication, host?: string);
+    buildFetchDashboardAccessTokensRequest(): Request<{
+        projectAdminOverrideToken: string | undefined;
+        dashboardAccessToken: string;
+    }>;
+    buildFetchGlobalLibrariesRequest(params: {
+        globalLibraryAccessTokens: string[];
+    }): Request<{
+        globalLibraryAccessTokens: string[];
+    }>;
+    buildFetchGlobalLibraryAccessTokensRequest(): Request<{
+        projectAdminOverrideToken: string | undefined;
+        dashboardAccessToken: string;
+    }>;
+    buildCreateDashboardRequest(params: CreateDashboardParams): Request<CreateDashboardParams & {
+        dashboardAccessToken: string;
+    }>;
+    buildFetchDashboardsRequest(dashboardSessionAccessTokens: string[]): Request<{}>;
+    createParentDashboard(params: nVizzlyApi.CreateParentDashboardParams): Promise<import("../types").Response<unknown>>;
+    buildCreateParentDashboardRequest(params: nVizzlyApi.CreateParentDashboardParams): Request<{}>;
+    createParentGlobalLibrary(params: nVizzlyApi.CreateParentGlobalLibraryParams): Promise<import("../types").Response<unknown>>;
+    buildCreateParentGlobalLibraryRequest(params: nVizzlyApi.CreateParentGlobalLibraryParams): Request<{}>;
+    createGlobalLibrary(params: nVizzlyApi.CreateGlobalLibraryParams): Promise<import("../types").Response<{
+        global_library: GlobalLibrary;
+        permissions: Array<GlobalLibraryPermission>;
+    }>>;
+    buildCreateGlobalLibraryRequest(params: nVizzlyApi.CreateGlobalLibraryParams): Request<{}>;
+    getProjects(): Promise<import("../types").Response<unknown>>;
+    buildGetProjectsRequest(): Request<{}>;
+    createProjectApiKey(params: nVizzlyApi.CreateProjectApiKeyParams): Promise<import("../types").Response<unknown>>;
+    buildCreateProjectApiKeyRequest(params: nVizzlyApi.CreateProjectApiKeyParams): Request<{}>;
+    createQueryEngineUser(params: nVizzlyApi.CreateQueryEngineUserParams): Promise<import("../types").Response<unknown>>;
+    buildCreateQueryEngineUserRequest(params: nVizzlyApi.CreateQueryEngineUserParams): Request<{}>;
+    buildCreateSelfHostedDynamicQueryEngineProjectRequest(): Request<{}>;
+    buildCreateSelfHostedInBrowserProjectRequest(): Request<{}>;
+    buildCreateSelfHostedProjectRequest(): Request<{}>;
+    createManagedQueryEngineProject(): Promise<import("../types").Response<unknown>>;
+    buildCreateManagedQueryEngineProjectRequest(): Request<{}>;
+    createVizzlyConfigVersion(params: nVizzlyApi.CreateVizzlyConfigVersionParams): Promise<import("../types").Response<unknown>>;
+    buildCreateVizzlyConfigVersionRequest(params: nVizzlyApi.CreateVizzlyConfigVersionParams): Request<{}>;
+    duplicateParentDashboard(params: nVizzlyApi.DuplicateParentDashboardParams): Promise<import("../types").Response<unknown>>;
+    buildDuplicateParentDashboardRequest(params: nVizzlyApi.DuplicateParentDashboardParams): Request<{}>;
+    getConnection(params: nVizzlyApi.GetConnectionParams): Promise<import("../types").Response<unknown>>;
+    buildGetConnectionRequest(params: nVizzlyApi.GetConnectionParams): Request<{}>;
+    getManagedQueryEngineKeyPair(params: nVizzlyApi.GetManagedQueryEngineKeyPairParams): Promise<import("../types").Response<unknown>>;
+    buildGetManagedQueryEngineKeyPairRequest(params: nVizzlyApi.GetManagedQueryEngineKeyPairParams): Request<{}>;
+    getProject(params: nVizzlyApi.GetProjectParams): Promise<import("../types").Response<unknown>>;
+    buildGetProjectRequest(params: nVizzlyApi.GetProjectParams): Request<{}>;
+    getProjectAccessToken(params: nVizzlyApi.GetProjectAccessTokenParams): Promise<import("../types").Response<unknown>>;
+    buildGetProjectAccessTokenRequest(params: nVizzlyApi.GetProjectAccessTokenParams): Request<{}>;
+    getQueryEngineUser(params: nVizzlyApi.GetQueryEngineUserParams): Promise<import("../types").Response<unknown>>;
+    buildGetQueryEngineUserRequest(params: nVizzlyApi.GetQueryEngineUserParams): Request<{}>;
+    getTeamMembers(params: nVizzlyApi.GetTeamMembers): Promise<import("../types").Response<unknown>>;
+    buildGetTeamMembersRequest(params: nVizzlyApi.GetTeamMembers): Request<{}>;
+    getVizzlyConfig(params: nVizzlyApi.GetVizzlyConfigParams): Promise<import("../types").Response<unknown>>;
+    buildGetVizzlyConfigRequest(params: nVizzlyApi.GetVizzlyConfigParams): Request<{}>;
+    saveConnection(params: nVizzlyApi.SaveConnectionParams): Promise<import("../types").Response<unknown>>;
+    buildSaveConnectionRequest(params: nVizzlyApi.SaveConnectionParams): Request<{}>;
+    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>>;
+    buildUpdateDashboardRequest(params: UpdateDashboardParams): Request<{}>;
+    updateParentGlobalLibrary(params: nVizzlyApi.UpdateParentGlobalLibraryParams): Promise<import("../types").Response<unknown>>;
+    buildUpdateParentGlobalLibraryRequest(params: nVizzlyApi.UpdateParentGlobalLibraryParams): Request<{}>;
+    updateGlobalLibrary(params: UpdateGlobalLibraryParams): Promise<import("../types").Response<unknown>>;
+    buildUpdateGlobalLibraryRequest(params: UpdateGlobalLibraryParams): Request<{}>;
+    updateProjectApiKey(params: nVizzlyApi.UpdateProjectApiKeyParams): Promise<import("../types").Response<unknown>>;
+    buildUpdateProjectApiKeyRequest(params: nVizzlyApi.UpdateProjectApiKeyParams): Request<{}>;
+    updateQueryEngineUser(params: nVizzlyApi.UpdateQueryEngineUserParams): Promise<import("../types").Response<unknown>>;
+    buildUpdateQueryEngineUserRequest(params: nVizzlyApi.UpdateQueryEngineUserParams): Request<{}>;
+}