@vizzly/api-client 0.0.20 → 0.0.23

package/dist/errors/FailedToCreateQueryEngineUser.d.ts

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

package/dist/errors/FailedToCreateQueryEngineUser.js

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

package/dist/errors/FailedToFetchProject.d.ts

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

package/dist/errors/FailedToFetchProject.js

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

package/dist/errors/FailedToFetchProjects.d.ts

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

package/dist/errors/FailedToFetchProjects.js

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

package/dist/errors/FailedToFetchQueryEngineUser.d.ts

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

package/dist/errors/FailedToFetchQueryEngineUser.js

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

package/dist/errors/FailedToFetchTeamMembers.d.ts

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

package/dist/errors/FailedToFetchTeamMembers.js

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

package/dist/errors/FailedToSaveProjectEncryptedEncryptionSecret.d.ts

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

package/dist/errors/FailedToSaveProjectEncryptedEncryptionSecret.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailedToSaveProjectEncryptedEncryptionSecret = void 0;
+class FailedToSaveProjectEncryptedEncryptionSecret extends Error {
+    constructor(projectId) {
+        super(`Failed to save project encrypted encryption secret for ${projectId}`);
+        this.name = 'FailedToSaveProjectEncryptedEncryptionSecret';
+    }
+}
+exports.FailedToSaveProjectEncryptedEncryptionSecret = FailedToSaveProjectEncryptedEncryptionSecret;

package/dist/errors/FailedToUpdateQueryEngineUser.d.ts

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

package/dist/errors/FailedToUpdateQueryEngineUser.js

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

package/dist/errors/ProjectEncryptedSecretAlreadySaved.d.ts

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

package/dist/errors/ProjectEncryptedSecretAlreadySaved.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectEncryptedSecretAlreadySaved = void 0;
+class ProjectEncryptedSecretAlreadySaved extends Error {
+    constructor(projectId) {
+        super(`Project encrypted encryption secret already exists for ${projectId}`);
+        this.name = 'ProjectEncryptedSecretAlreadySaved';
+    }
+}
+exports.ProjectEncryptedSecretAlreadySaved = ProjectEncryptedSecretAlreadySaved;

package/dist/errors/index.d.ts

@@ -14,3 +14,10 @@ export * from './FailedToUpdateDashboard';
 export * from './FailedToFetchVizzlyConfig';
 export * from './ConnectionDoesNotExistOnProject';
 export * from './FailedToFetchConnection';
+export * from './FailedToFetchProject';
+export * from './FailedToFetchProjects';
+export * from './FailedToFetchTeamMembers';
+export * from './FailedToCreateQueryEngineUser';
+export * from './FailedToFetchQueryEngineUser';
+export * from './ProjectEncryptedSecretAlreadySaved';
+export * from './FailedToSaveProjectEncryptedEncryptionSecret';

package/dist/errors/index.js

@@ -30,3 +30,10 @@ __exportStar(require("./FailedToUpdateDashboard"), exports);
 __exportStar(require("./FailedToFetchVizzlyConfig"), exports);
 __exportStar(require("./ConnectionDoesNotExistOnProject"), exports);
 __exportStar(require("./FailedToFetchConnection"), exports);
+__exportStar(require("./FailedToFetchProject"), exports);
+__exportStar(require("./FailedToFetchProjects"), exports);
+__exportStar(require("./FailedToFetchTeamMembers"), exports);
+__exportStar(require("./FailedToCreateQueryEngineUser"), exports);
+__exportStar(require("./FailedToFetchQueryEngineUser"), exports);
+__exportStar(require("./ProjectEncryptedSecretAlreadySaved"), exports);
+__exportStar(require("./FailedToSaveProjectEncryptedEncryptionSecret"), exports);

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/dist/models/VizzlyApi.d.ts

@@ -1,7 +1,8 @@
 import { Api } from './Api';
 import { Authentication } from './Authentication';
-import { CreateDashboardParams, CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermission, GlobalLibraryPermissionFromAPI, Request, RequestParams, UpdateDashboardParams, UpdateDashboardResponseBody, UpdateGlobalLibraryParams } from '../types';
+import { CreateDashboardParams, CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermission, GlobalLibraryPermissionFromAPI, QueryEngineUserFromAPI, Request, RequestParams, TeamMemberFromAPI, UpdateDashboardParams, UpdateDashboardResponseBody, UpdateGlobalLibraryParams } from '../types';
 import { nVizzlyApi } from '../types';
+import { ProjectFromAPI } from '../types/project';
 export declare class VizzlyApi extends Api {
     constructor(auth: Authentication, host?: string);
     buildFetchDashboardAccessTokensRequest(params?: RequestParams): Request<{
@@ -42,13 +43,15 @@ export declare class VizzlyApi extends Api {
         permissions: Array<GlobalLibraryPermission>;
     }>;
     buildCreateGlobalLibraryRequest(params: RequestParams<CreateGlobalLibraryParams>): Request<{}>;
-    getProjects(params?: RequestParams): Promise<import("../types").Response<unknown>>;
+    getProjects(params?: RequestParams): Promise<{
+        projects: Array<ProjectFromAPI>;
+    }>;
     buildGetProjectsRequest(params?: RequestParams): Request<{}>;
     createProjectApiKey(params: RequestParams<nVizzlyApi.CreateProjectApiKeyParams>): Promise<import("../types").Response<{
         api_key: string;
     }>>;
     buildCreateProjectApiKeyRequest(params: RequestParams<nVizzlyApi.CreateProjectApiKeyParams>): Request<{}>;
-    createQueryEngineUser(params: RequestParams<nVizzlyApi.CreateQueryEngineUserParams>): Promise<import("../types").Response<unknown>>;
+    createQueryEngineUser(params: RequestParams<nVizzlyApi.CreateQueryEngineUserParams>): Promise<QueryEngineUserFromAPI>;
     buildCreateQueryEngineUserRequest(params: RequestParams<nVizzlyApi.CreateQueryEngineUserParams>): Request<{}>;
     buildCreateSelfHostedDynamicQueryEngineProjectRequest(params?: RequestParams): Request<{}>;
     buildCreateSelfHostedInBrowserProjectRequest(params?: RequestParams): Request<{}>;
@@ -65,7 +68,9 @@ export declare class VizzlyApi extends Api {
     buildGetConnectionRequest(params: RequestParams<nVizzlyApi.GetConnectionParams>): Request<{}>;
     getManagedQueryEngineKeyPair(params: RequestParams<nVizzlyApi.GetManagedQueryEngineKeyPairParams>): Promise<import("../types").Response<unknown>>;
     buildGetManagedQueryEngineKeyPairRequest(params: RequestParams<nVizzlyApi.GetManagedQueryEngineKeyPairParams>): Request<{}>;
-    getProject(params: RequestParams<nVizzlyApi.GetProjectParams>): Promise<import("../types").Response<unknown>>;
+    getProject(params: RequestParams<nVizzlyApi.GetProjectParams>): Promise<{
+        project: ProjectFromAPI;
+    }>;
     buildGetProjectRequest(params: RequestParams<nVizzlyApi.GetProjectParams>): Request<{}>;
     getProjectAccessToken(params: RequestParams<nVizzlyApi.GetProjectAccessTokenParams>): Promise<import("../types").Response<{
         token: {
@@ -74,9 +79,11 @@ export declare class VizzlyApi extends Api {
         };
     }>>;
     buildGetProjectAccessTokenRequest(params: RequestParams<nVizzlyApi.GetProjectAccessTokenParams>): Request<{}>;
-    getQueryEngineUser(params: RequestParams<nVizzlyApi.GetQueryEngineUserParams>): Promise<import("../types").Response<unknown>>;
+    getQueryEngineUser(params: RequestParams<nVizzlyApi.GetQueryEngineUserParams>): Promise<QueryEngineUserFromAPI>;
     buildGetQueryEngineUserRequest(params: RequestParams<nVizzlyApi.GetQueryEngineUserParams>): Request<{}>;
-    getTeamMembers(params: RequestParams<nVizzlyApi.GetTeamMembers>): Promise<import("../types").Response<unknown>>;
+    getTeamMembers(params: RequestParams<nVizzlyApi.GetTeamMembers>): Promise<{
+        team_members: Array<TeamMemberFromAPI>;
+    }>;
     buildGetTeamMembersRequest(params: RequestParams<nVizzlyApi.GetTeamMembers>): Request<{}>;
     getVizzlyConfig(params: RequestParams<nVizzlyApi.GetVizzlyConfigParams>): Promise<{
         encryptedConfig: string | null;
@@ -84,6 +91,7 @@ export declare class VizzlyApi extends Api {
     buildGetVizzlyConfigRequest(params: RequestParams<nVizzlyApi.GetVizzlyConfigParams>): Request<{}>;
     saveConnection(params: RequestParams<nVizzlyApi.SaveConnectionParams>): Promise<import("../types").Response<unknown>>;
     buildSaveConnectionRequest(params: RequestParams<nVizzlyApi.SaveConnectionParams>): Request<{}>;
+    saveEncryptedProjectEncryptionSecret(params: RequestParams<nVizzlyApi.SaveEncryptedProjectEncryptionSecretParams>): Promise<boolean>;
     buildSaveEncryptedProjectEncryptionSecretRequest(params: RequestParams<nVizzlyApi.SaveEncryptedProjectEncryptionSecretParams>): Request<{}>;
     saveScheduledReport(params: RequestParams<nVizzlyApi.SaveScheduledReportParams>): Promise<import("../types").Response<unknown>>;
     buildSaveScheduledReportRequest(params: RequestParams<nVizzlyApi.SaveScheduledReportParams>): Request<{}>;
@@ -97,6 +105,6 @@ export declare class VizzlyApi extends Api {
     buildUpdateGlobalLibraryRequest(params: RequestParams<UpdateGlobalLibraryParams>): Request<{}>;
     updateProjectApiKey(params: RequestParams<nVizzlyApi.UpdateProjectApiKeyParams>): Promise<import("../types").Response<unknown>>;
     buildUpdateProjectApiKeyRequest(params: RequestParams<nVizzlyApi.UpdateProjectApiKeyParams>): Request<{}>;
-    updateQueryEngineUser(params: RequestParams<nVizzlyApi.UpdateQueryEngineUserParams>): Promise<import("../types").Response<unknown>>;
+    updateQueryEngineUser(params: RequestParams<nVizzlyApi.UpdateQueryEngineUserParams>): Promise<boolean>;
     buildUpdateQueryEngineUserRequest(params: RequestParams<nVizzlyApi.UpdateQueryEngineUserParams>): Request<{}>;
 }

package/dist/models/VizzlyApi.js

@@ -15,6 +15,10 @@ const errors_1 = require("../errors");
 const FailedToFetchVizzlyConfig_1 = require("../errors/FailedToFetchVizzlyConfig");
 const ConnectionDoesNotExistOnProject_1 = require("../errors/ConnectionDoesNotExistOnProject");
 const FailedToFetchConnection_1 = require("../errors/FailedToFetchConnection");
+const FailedToFetchProject_1 = require("../errors/FailedToFetchProject");
+const FailedToUpdateQueryEngineUser_1 = require("../errors/FailedToUpdateQueryEngineUser");
+const FailedToSaveProjectEncryptedEncryptionSecret_1 = require("../errors/FailedToSaveProjectEncryptedEncryptionSecret");
+const ProjectEncryptedSecretAlreadySaved_1 = require("../errors/ProjectEncryptedSecretAlreadySaved");
 class VizzlyApi extends Api_1.Api {
     constructor(auth, host = 'https://api.vizzly.co') {
         super(auth, host);
@@ -140,7 +144,10 @@ class VizzlyApi extends Api_1.Api {
     }
     getProjects(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.execute(this.buildGetProjectsRequest(params));
+            const response = yield this.execute(this.buildGetProjectsRequest(params));
+            if (response.status === 200)
+                return { projects: response.body.projects };
+            throw new errors_1.FailedToFetchProjects(`Failed to fetch projects. Got status ${response.status}`);
         });
     }
     buildGetProjectsRequest(params) {
@@ -168,7 +175,10 @@ class VizzlyApi extends Api_1.Api {
     }
     createQueryEngineUser(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.execute(this.buildCreateQueryEngineUserRequest(params));
+            const response = yield this.execute(this.buildCreateQueryEngineUserRequest(params));
+            if (response.status === 200)
+                return response.body.query_engine_user;
+            throw new errors_1.FailedToCreateQueryEngineUser(`Failed to create query engine user. Got status ${response.status}`);
         });
     }
     buildCreateQueryEngineUserRequest(params) {
@@ -287,7 +297,10 @@ class VizzlyApi extends Api_1.Api {
     }
     getProject(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.execute(this.buildGetProjectRequest(params));
+            const getProjectResponse = yield this.execute(this.buildGetProjectRequest(params));
+            if (getProjectResponse.status === 200)
+                return getProjectResponse.body;
+            throw new FailedToFetchProject_1.FailedToFetchProject(`Failed to fetch project. Got status ${getProjectResponse.status}`);
         });
     }
     buildGetProjectRequest(params) {
@@ -314,7 +327,10 @@ class VizzlyApi extends Api_1.Api {
     }
     getQueryEngineUser(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.execute(this.buildGetQueryEngineUserRequest(params));
+            const response = yield this.execute(this.buildGetQueryEngineUserRequest(params));
+            if (response.status === 200)
+                return response.body.query_engine_user;
+            throw new errors_1.FailedToFetchQueryEngineUser(`Failed to fetch query engine user. Got status ${response.status}`);
         });
     }
     buildGetQueryEngineUserRequest(params) {
@@ -326,7 +342,10 @@ class VizzlyApi extends Api_1.Api {
     }
     getTeamMembers(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.execute(this.buildGetTeamMembersRequest(params));
+            const response = yield this.execute(this.buildGetTeamMembersRequest(params));
+            if (response.status === 200)
+                return response.body;
+            throw new errors_1.FailedToFetchTeamMembers(`Failed to fetch team members. Got status ${response.status}`);
         });
     }
     buildGetTeamMembersRequest(params) {
@@ -371,6 +390,19 @@ class VizzlyApi extends Api_1.Api {
             abortSignal: params.abortSignal,
         };
     }
+    saveEncryptedProjectEncryptionSecret(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.execute(this.buildSaveEncryptedProjectEncryptionSecretRequest(params));
+            if (response.status === 200)
+                return true;
+            if (response.status == 400 && !params.allowRotation) {
+                // We're not allowing rotation, so we are trying to set the first encrypted secret, but
+                // one already exists.
+                throw new ProjectEncryptedSecretAlreadySaved_1.ProjectEncryptedSecretAlreadySaved(params.projectId);
+            }
+            throw new FailedToSaveProjectEncryptedEncryptionSecret_1.FailedToSaveProjectEncryptedEncryptionSecret(params.projectId);
+        });
+    }
     buildSaveEncryptedProjectEncryptionSecretRequest(params) {
         return {
             path: `/api/v3/project/${params.projectId}/encrypted-encryption-secret`,
@@ -469,7 +501,10 @@ class VizzlyApi extends Api_1.Api {
     }
     updateQueryEngineUser(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.execute(this.buildUpdateQueryEngineUserRequest(params));
+            const response = yield this.execute(this.buildUpdateQueryEngineUserRequest(params));
+            if (response.status === 200)
+                return true;
+            throw new FailedToUpdateQueryEngineUser_1.FailedToUpdateQueryEngineUser(`Failed to update query engine user. Got status ${response.status}`);
         });
     }
     buildUpdateQueryEngineUserRequest(params) {

package/dist/types/project.d.ts

@@ -0,0 +1,69 @@
+import { DashboardFromAPI, GlobalLibrary } from '../types';
+export type ProjectType = 'instant_dashboard' | 'self_hosted' | 'managed_query_engine' | 'in_browser' | 'dynamic_self_hosted_query_engine';
+export type ProjectFromAPI = {
+    instant_dashboard_id: string | null;
+    managed_query_engine_id: string | null;
+    id: string;
+    name: string;
+    type: ProjectType;
+    created_at: Date;
+    share_links?: ShareLink[];
+    parent_dashboards: DashboardFromAPI[];
+    parent_global_libraries: GlobalLibrary[];
+    key_pairs: RawKeyPair[];
+    encrypted_encryption_secret: string | null;
+    query_engine_users: Array<{
+        id: string;
+        /** Hashed and encrypted using the encryption secret on the query engine */
+        password: string | null;
+        user: {
+            id: string;
+            email: string;
+            first_name: string;
+            last_name: string;
+        };
+    }>;
+    config_store: {
+        id: string;
+        versions: Array<{
+            id: string;
+            created_at: string;
+            updated_at: string;
+        }>;
+    };
+    connections: Array<{
+        id: string;
+        created_at: string;
+        updated_at: string;
+        disabled: boolean;
+    }>;
+    api_keys: Array<{
+        id: string;
+        created_at: string;
+        disabled: boolean;
+    }>;
+    deleted: boolean;
+    data_upload: {
+        created_at: string;
+        id: string;
+        updated_at: string;
+    };
+};
+type ShareLink = {
+    id: string;
+    token: string;
+    active: boolean;
+    created_at: string;
+    title: string;
+    email: string | null;
+};
+type RawKeyPair = {
+    id: string;
+    uploaded_by: string;
+    public_key: string;
+    organisation_id: string;
+    uploaded_at: string;
+    updated_at: string;
+    disabled: boolean;
+};
+export {};

package/dist/types/project.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/team.d.ts

@@ -0,0 +1,11 @@
+export type TeamMemberFromAPI = {
+    id: string;
+    organisation_name: string;
+    user_id: string;
+    department: string;
+    email: string;
+    first_name: string;
+    last_name: string;
+    status: 'pending' | 'active' | 'removed';
+    organisation_id: string;
+};

package/dist/types/team.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/user.d.ts

@@ -0,0 +1,15 @@
+export type QueryEngineUserFromAPI = {
+    id: string;
+    password: string | null;
+    user: UserFromAPI;
+};
+export type UserFromAPI = {
+    active: boolean;
+    department: string;
+    email: string;
+    first_name: string;
+    id: string;
+    is_email_verified: boolean;
+    is_vizz: boolean;
+    last_name: string;
+};

package/dist/types/user.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.d.ts

@@ -3,6 +3,9 @@ import { VizzlyApi } from './models/VizzlyApi';
 import { VizzlyAppApi } from './models/VizzlyAppApi';
 import { DashboardDefinition, DashboardFromAPI } from './types/dashboard';
 export * from './types/dashboard';
+export * from './types/project';
+export * from './types/team';
+export * from './types/user';
 export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type UpdateDashboardResponseBody = {
     dashboard: DashboardFromAPI;

package/dist/types.js

@@ -15,3 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types/dashboard"), exports);
+__exportStar(require("./types/project"), exports);
+__exportStar(require("./types/team"), exports);
+__exportStar(require("./types/user"), exports);

package/package.json

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