@vizzly/api-client 0.0.26 → 0.0.28

package/dist/errors/FailedToUpdateGlobalLibrary.d.ts

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

package/dist/errors/FailedToUpdateGlobalLibrary.js

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

package/dist/models/DashboardManager.js

@@ -147,7 +147,7 @@ class DashboardManager {
         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 }) })));
+        return (componentLibrary || []).map((view) => (Object.assign(Object.assign({}, view), { attributes: Object.assign(Object.assign({}, view.attributes), { protectedByOrganisation: true }) })));
     }
 }
 exports.DashboardManager = DashboardManager;

package/dist/models/DashboardRepository.d.ts

@@ -20,4 +20,5 @@ export declare class DashboardRepository {
         dashboards: Dashboard[];
         permissions: DashboardPermission[];
     }>;
+    clearRepo(): void;
 }

package/dist/models/DashboardRepository.js

@@ -123,5 +123,8 @@ class DashboardRepository {
             };
         });
     }
+    clearRepo() {
+        this.repo.clear();
+    }
 }
 exports.DashboardRepository = DashboardRepository;

package/dist/models/GlobalLibraryManager.d.ts

@@ -0,0 +1,15 @@
+import { Vizzly } from './Vizzly';
+import { CreateGlobalLibraryParams, GlobalLibrary, RequestParams, UpdateGlobalLibraryParams } from '../types';
+import { GlobalLibraryType } from '../types/globalLibrary';
+export declare class GlobalLibraryManager {
+    private vizzly;
+    constructor(vizzly: Vizzly);
+    create(params: RequestParams<CreateGlobalLibraryParams>): Promise<{
+        permissions: import("../types").GlobalLibraryPermission[];
+        global_library: GlobalLibrary;
+    }>;
+    update(params: RequestParams<UpdateGlobalLibraryParams & {
+        globalLibraryId: string;
+    }>): Promise<GlobalLibrary>;
+    getGlobalLibraries(params?: RequestParams): Promise<GlobalLibraryType>;
+}

package/dist/models/GlobalLibraryManager.js

@@ -0,0 +1,49 @@
+"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.GlobalLibraryManager = void 0;
+class GlobalLibraryManager {
+    constructor(vizzly) {
+        this.vizzly = vizzly;
+    }
+    create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const repository = this.vizzly.getGlobalLibraryRepository();
+            return yield repository.createGlobalLibrary(params);
+        });
+    }
+    update(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const globalLibraryRepository = this.vizzly.getGlobalLibraryRepository();
+            const { global_libraries: globalLibraries, permissions: globalLibraryPermissions } = yield globalLibraryRepository.fetchGlobalLibraries(params);
+            const globalLibraryToUpdate = globalLibraries.find((gL) => gL.id === params.globalLibraryId);
+            if (!globalLibraryToUpdate) {
+                throw new Error('Global library not found');
+            }
+            const writePermission = globalLibraryPermissions.find((permission) => permission.globalLibraryId === params.globalLibraryId && permission.scope === 'read_write');
+            if (!writePermission) {
+                throw new Error('No write permission for this library');
+            }
+            const response = yield globalLibraryRepository.updateGlobalLibrary({
+                globalLibrarySessionToken: writePermission.token,
+                library: params.library,
+            });
+            return response;
+        });
+    }
+    getGlobalLibraries(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const repository = this.vizzly.getGlobalLibraryRepository();
+            return yield repository.fetchGlobalLibraries(params);
+        });
+    }
+}
+exports.GlobalLibraryManager = GlobalLibraryManager;

package/dist/models/GlobalLibraryRepository.d.ts

@@ -1,4 +1,4 @@
-import { CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermission, RequestParams, Response, UpdateGlobalLibraryParams } from '../types';
+import { CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermission, RequestParams, UpdateGlobalLibraryParams } from '../types';
 import { Vizzly } from './Vizzly';
 export declare class GlobalLibraryRepository {
     private vizzly;
@@ -16,9 +16,7 @@ export declare class GlobalLibraryRepository {
         global_libraries: GlobalLibrary[];
         permissions: GlobalLibraryPermission[];
     }>;
-    updateGlobalLibrary(params: UpdateGlobalLibraryParams): Promise<Response<{
-        global_library: GlobalLibrary;
-    }>>;
+    updateGlobalLibrary(params: UpdateGlobalLibraryParams): Promise<GlobalLibrary>;
     getChildGlobalLibrariesByParentGlobalLibraryId(parentGlobalLibraryId: string): Promise<GlobalLibrary[]>;
     static splitParentAndChildGlobalLibraries(globalLibraries: GlobalLibrary[]): {
         childGlobalLibraries: GlobalLibrary[];
@@ -31,4 +29,5 @@ export declare class GlobalLibraryRepository {
     static mapParentToChildGlobalLibraries(globalLibraries: GlobalLibrary[]): {
         [parentGlobalLibraryId: string]: GlobalLibrary[];
     };
+    static upcast(globalLibrary: GlobalLibrary): GlobalLibrary;
 }

package/dist/models/GlobalLibraryRepository.js

@@ -14,6 +14,7 @@ const lodash_1 = require("lodash");
 const Permission_1 = require("./Permission");
 const FailedToFetchGlobalLibraryAccessTokens_1 = require("../errors/FailedToFetchGlobalLibraryAccessTokens");
 const Repository_1 = require("./Repository");
+const FailedToUpdateGlobalLibrary_1 = require("../errors/FailedToUpdateGlobalLibrary");
 class GlobalLibraryRepository {
     constructor(vizzly) {
         this.vizzly = vizzly;
@@ -30,6 +31,7 @@ class GlobalLibraryRepository {
             else {
                 globalLibrary = yield vizzlyApi.createGlobalLibrary(createParams);
             }
+            globalLibrary.global_library = GlobalLibraryRepository.upcast(globalLibrary.global_library);
             this.repo.addItem(globalLibrary.global_library, globalLibrary.permissions);
             return globalLibrary;
         });
@@ -54,7 +56,7 @@ class GlobalLibraryRepository {
                 }
                 if (accessTokens.status === 200) {
                     const formattedPermissions = accessTokens.body.permissions.map(Permission_1.Permission.formatGlobalLibraryPermission);
-                    this.repo.initRepo(accessTokens.body.global_libraries, formattedPermissions);
+                    this.repo.initRepo(accessTokens.body.global_libraries.map(GlobalLibraryRepository.upcast), formattedPermissions);
                 }
                 else {
                     throw new FailedToFetchGlobalLibraryAccessTokens_1.FailedToFetchGlobalLibraryAccessTokens('Failed to load access tokens for the global library.');
@@ -68,8 +70,8 @@ class GlobalLibraryRepository {
     }
     updateGlobalLibrary(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const vizzlyApi = this.vizzly.getVizzlyAPI();
             let updateResponse;
+            const vizzlyApi = this.vizzly.getVizzlyAPI();
             if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
                 const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
                 updateResponse = yield vizzlyQueryEngineApi.updateGlobalLibrary(params);
@@ -77,10 +79,12 @@ class GlobalLibraryRepository {
             else {
                 updateResponse = yield vizzlyApi.updateGlobalLibrary(params);
             }
-            if (updateResponse.status === 200) {
-                this.repo.updateItem(updateResponse.body.global_library);
+            if (updateResponse.status != 200) {
+                throw new FailedToUpdateGlobalLibrary_1.FailedToUpdateGlobalLibrary(`Failed to update the global library ${updateResponse.status}`);
             }
-            return updateResponse;
+            const globalLibrary = GlobalLibraryRepository.upcast(updateResponse.body.global_library);
+            this.repo.updateItem(globalLibrary);
+            return globalLibrary;
         });
     }
     getChildGlobalLibrariesByParentGlobalLibraryId(parentGlobalLibraryId) {
@@ -123,5 +127,8 @@ class GlobalLibraryRepository {
         });
         return mapping;
     }
+    static upcast(globalLibrary) {
+        return Object.assign(Object.assign({}, globalLibrary), { library: Object.assign({ views: [], customFields: {} }, (globalLibrary.library || {})) });
+    }
 }
 exports.GlobalLibraryRepository = GlobalLibraryRepository;

package/dist/models/Repository.d.ts

@@ -14,4 +14,5 @@ export declare class Repository<StoreType, PermissionType extends {
     updateItem(newValue: StoreType): void;
     isPopulated(): boolean;
     private permissionsAreFresh;
+    clear(): void;
 }

package/dist/models/Repository.js

@@ -43,5 +43,9 @@ class Repository {
             return Permission_1.Permission.validateJwtExpiry(permission.token);
         });
     }
+    clear() {
+        this.storedItems = [];
+        this.permissions = [];
+    }
 }
 exports.Repository = Repository;

package/dist/models/Vizzly.d.ts

@@ -3,12 +3,14 @@ import { ImplementationStrategy, PersistDirectToVizzlyApi } from './Implementati
 import { DashboardRepository } from './DashboardRepository';
 import { GlobalLibraryRepository } from './GlobalLibraryRepository';
 import { DashboardManager } from './DashboardManager';
+import { GlobalLibraryManager } from './GlobalLibraryManager';
 export declare class Vizzly {
     private APIs;
     implementationStrategy: ImplementationStrategy;
     private dashboardRepository;
     private globalLibraryRepository;
     private dashboardManager;
+    private globalLibraryManager;
     constructor(APIs: PartialBy<APIs, 'vizzlyQueryEngineApi'>, implementationStrategy: PersistDirectToVizzlyApi);
     getAPIs(): APIs | PartialBy<APIs, 'vizzlyQueryEngineApi'>;
     getVizzlyAppApi(): import("./VizzlyAppApi").VizzlyAppApi;
@@ -17,4 +19,5 @@ export declare class Vizzly {
     getDashboardRepository(): DashboardRepository;
     getGlobalLibraryRepository(): GlobalLibraryRepository;
     getDashboardManager(): DashboardManager;
+    getGlobalLibraryManager(): GlobalLibraryManager;
 }

package/dist/models/Vizzly.js

@@ -5,6 +5,7 @@ const MissingRequiredVizzlyQueryEngineApi_1 = require("../errors/MissingRequired
 const DashboardRepository_1 = require("./DashboardRepository");
 const GlobalLibraryRepository_1 = require("./GlobalLibraryRepository");
 const DashboardManager_1 = require("./DashboardManager");
+const GlobalLibraryManager_1 = require("./GlobalLibraryManager");
 class Vizzly {
     constructor(APIs, implementationStrategy) {
         this.APIs = APIs;
@@ -12,6 +13,7 @@ class Vizzly {
         this.dashboardManager = new DashboardManager_1.DashboardManager(this);
         this.dashboardRepository = new DashboardRepository_1.DashboardRepository(this);
         this.globalLibraryRepository = new GlobalLibraryRepository_1.GlobalLibraryRepository(this);
+        this.globalLibraryManager = new GlobalLibraryManager_1.GlobalLibraryManager(this);
     }
     getAPIs() {
         if (this.implementationStrategy.shouldPersistViaQueryEngine() && !this.APIs.vizzlyQueryEngineApi) {
@@ -37,5 +39,8 @@ class Vizzly {
     getDashboardManager() {
         return this.dashboardManager;
     }
+    getGlobalLibraryManager() {
+        return this.globalLibraryManager;
+    }
 }
 exports.Vizzly = Vizzly;

package/dist/types/globalLibrary.d.ts

@@ -0,0 +1,5 @@
+import { GlobalLibrary, GlobalLibraryPermission } from '../types';
+export type GlobalLibraryType = {
+    global_libraries: GlobalLibrary[];
+    permissions: GlobalLibraryPermission[];
+};

package/dist/types/globalLibrary.js

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

package/package.json

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