passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/service/api/passwordPolicies/passwordPoliciesService.test.js

@@ -0,0 +1,127 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.3.0
+ */
+
+import {enableFetchMocks} from "jest-fetch-mock";
+import {mockApiResponse, mockApiResponseError} from "../../../../../../test/mocks/mockApiResponse";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
+import AccountEntity from "../../../model/entity/account/accountEntity";
+import BuildApiClientOptionsService from "../../account/buildApiClientOptionsService";
+import {defaultAccountDto} from "../../../model/entity/account/accountEntity.test.data";
+import {defaultPasswordPolicies} from "../../../model/entity/passwordPolicies/passwordPoliciesEntity.test.data";
+import PasswordPoliciesService from "./passwordPoliciesService";
+
+describe("PasswordPoliciesService", () => {
+  let apiClientOptions;
+
+  beforeEach(async() => {
+    enableFetchMocks();
+    fetch.resetMocks();
+    jest.spyOn(browser.cookies, "get").mockImplementationOnce(() => ({value: "csrf-token"}));
+
+    const account = new AccountEntity(defaultAccountDto());
+    apiClientOptions = await BuildApiClientOptionsService.buildFromAccount(account);
+  });
+
+  describe("::find", () => {
+    it("should find the value from the API", async() => {
+      expect.assertions(1);
+      const expectedDto = defaultPasswordPolicies({
+        default_generator: "passphrase"
+      });
+      fetch.doMockOnceIf(/password-policies\/settings\.json/, () => mockApiResponse(expectedDto));
+
+      const service = new PasswordPoliciesService(apiClientOptions);
+      const resultDto = await service.find();
+
+      expect(resultDto).toStrictEqual(expectedDto);
+    });
+
+    it("should fallback to the former endpoint if something goes wrong", async() => {
+      expect.assertions(1);
+      const oldFormatDto = {
+        default_generator: "passphrase"
+      };
+
+      fetch.doMockOnceIf(/password-policies\/settings\.json/, () => mockApiResponseError(404, "Endpoint is not existing"));
+      fetch.doMockOnceIf(/password-generator\/settings\.json/, () => mockApiResponse(oldFormatDto));
+
+      const service = new PasswordPoliciesService(apiClientOptions);
+      const resultDto = await service.find();
+
+      expect(resultDto).toStrictEqual(oldFormatDto);
+    });
+
+    it("should throw an exception if something goes wrong on the API", async() => {
+      expect.assertions(1);
+
+      fetch.doMockOnceIf(/password-policies\/settings\.json/, () => mockApiResponseError(404, "Endpoint is not existing"));
+      fetch.doMockOnceIf(/password-generator\/settings\.json/, () => mockApiResponseError(500, "Something went wrong"));
+
+      const service = new PasswordPoliciesService(apiClientOptions);
+      try {
+        await service.find();
+      } catch (e) {
+        expect(e).toBeInstanceOf(PassboltApiFetchError);
+      }
+    });
+  });
+
+  describe("::save", () => {
+    it("should call the api to save the settings", async() => {
+      expect.assertions(2);
+      const expectedDto = defaultPasswordPolicies({
+        default_generator: "passphrase"
+      });
+
+      fetch.doMockOnceIf(/password-policies\/settings\.json/, async request => {
+        const body = JSON.parse(await request.text());
+        expect(body).toStrictEqual(expectedDto);
+        return mockApiResponse(expectedDto);
+      });
+
+      const service = new PasswordPoliciesService(apiClientOptions);
+      const resultDto = await service.save(expectedDto);
+
+      expect(resultDto).toStrictEqual(expectedDto);
+    });
+
+    it("should throw an exception if something goes wrong on the API", async() => {
+      expect.assertions(1);
+      const expectedDto = defaultPasswordPolicies({
+        default_generator: "passphrase"
+      });
+
+      fetch.doMockOnceIf(/password-policies\/settings\.json/, () => mockApiResponseError(500, "something went wrong!"));
+
+      const service = new PasswordPoliciesService(apiClientOptions);
+
+      try {
+        await service.save(expectedDto);
+      } catch (e) {
+        expect(e).toBeInstanceOf(PassboltApiFetchError);
+      }
+    });
+
+    it("should throw an exception if no data is passed when saving", async() => {
+      expect.assertions(1);
+      const service = new PasswordPoliciesService(apiClientOptions);
+
+      try {
+        await service.save();
+      } catch (e) {
+        expect(e).toBeInstanceOf(TypeError);
+      }
+    });
+  });
+});

package/src/all/background_page/service/api/resource/resourceLocalStorageUpdateService.js

@@ -0,0 +1,112 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.6.0
+ */
+import ResourceLocalStorage from "../../local_storage/resourceLocalStorage";
+import ResourcesCollection from "../../../model/entity/resource/resourcesCollection";
+import ResourceService from "./resourceService";
+
+
+const TIMER = 5000;
+const lastTimeCalledPerAccount = {};
+const RESOURCE_UPDATE_LOCK = 'resourceUpdateLock';
+/**
+ * The ResourceLocalStorageUpdateService perform a get or update the resources local storage
+ */
+class ResourceLocalStorageUpdateService {
+  /**
+   *
+   * @param {AccountEntity} account The user account
+   * @param {ApiClientOptions} apiClientOptions The api client options
+   */
+  constructor(account, apiClientOptions) {
+    this.account = account;
+    this.storageKey = this.getStorageKey(account);
+    this.resourceService = new ResourceService(apiClientOptions);
+  }
+
+  /**
+   * Get or find the password expiry settings in local storage.
+   * @param {boolean} forceUpdate
+   * @return {Promise<ResourcesCollection>}
+   */
+  async exec(forceUpdate = false) {
+    return await navigator.locks.request(this.storageKey, () => this.getOrUpdateLocalStorage(forceUpdate));
+  }
+
+  /**
+   * Get or update the resources in local storage.
+   * @private
+   * @param {boolean} forceUpdate
+   * @return {Promise<ResourcesCollection>}
+   */
+  async getOrUpdateLocalStorage(forceUpdate = false) {
+    if (forceUpdate && this.isTimeOverdue) {
+      return this.updateLocalStorage();
+    }
+
+    const resources = await ResourceLocalStorage.get();
+    if (resources) {
+      return new ResourcesCollection(resources, {clone: false});
+    }
+    return this.updateLocalStorage();
+  }
+
+  /**
+   * Is time overdue
+   * @private
+   * @returns {boolean}
+   */
+  get isTimeOverdue() {
+    const lastTimeCalled = lastTimeCalledPerAccount[this.account.id] || 0;
+    return Date.now() - lastTimeCalled > TIMER;
+  }
+
+
+  /**
+   * Update the resources in local storage
+   * @private
+   * @returns {Promise<ResourcesCollection>}
+   */
+  async updateLocalStorage() {
+    let resourcesDto = await this.resourceService.findAll(ResourceLocalStorageUpdateService.DEFAULT_CONTAIN);
+    resourcesDto = ResourcesCollection.sanitizeDto(resourcesDto);
+    const resourcesCollection = new ResourcesCollection(resourcesDto, {clone: false});
+    await ResourceLocalStorage.set(resourcesCollection);
+    lastTimeCalledPerAccount[this.account.id] = Date.now();
+    return resourcesCollection;
+  }
+
+  /**
+   * ResourceLocalStorageUpdateService.DEFAULT_CONTAIN
+   * @private
+   * @returns {Object}
+   */
+  static get DEFAULT_CONTAIN() {
+    return {permission: true, favorite: true, tag: true};
+  }
+
+  /**
+   * Get the storage key.
+   * @param {AbstractAccountEntity} account The account to get the key for.
+   * @returns {string}
+   * @throws {Error} If it cannot retrieve account id.
+   */
+  getStorageKey(account) {
+    if (!account.id) {
+      throw new Error('Cannot retrieve account id, necessary to lock the password expiry settings get or find service.');
+    }
+    return `${RESOURCE_UPDATE_LOCK}-${account.id}`;
+  }
+}
+
+export default ResourceLocalStorageUpdateService;

package/src/all/background_page/service/api/resource/resourceLocalStorageUpdateService.test.js

@@ -0,0 +1,109 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.6.0
+ */
+
+
+import {defaultResourceDto} from "passbolt-styleguide/src/shared/models/entity/resource/resourceEntity.test.data";
+import {ownerPermissionDto} from "passbolt-styleguide/src/shared/models/entity/permission/permissionEntity.test.data.js";
+import ResourceService from "./resourceService";
+import {ApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions";
+import ResourceLocalStorageUpdateService from "./resourceLocalStorageUpdateService";
+import ResourcesCollection from "../../../model/entity/resource/resourcesCollection";
+import ResourceLocalStorage from "../../local_storage/resourceLocalStorage";
+import AccountEntity from "../../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../../model/entity/account/accountEntity.test.data";
+
+jest.useFakeTimers();
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  jest.clearAllTimers();
+  jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => {
+    const resource1 = defaultResourceDto({name: "Resource1"});
+    resource1.permission = ownerPermissionDto({aco_foreign_key: resource1.id});
+    delete resource1.secrets;
+    const resource2 = defaultResourceDto({name: "Resource2"});
+    resource2.permission = ownerPermissionDto({aco_foreign_key: resource2.id});
+    delete resource2.secrets;
+    const resource3 = defaultResourceDto({name: "Resource3"});
+    resource3.permission = ownerPermissionDto({aco_foreign_key: resource3.id});
+    delete resource3.secrets;
+    const resource4 = defaultResourceDto({name: "Resource4"});
+    resource4.permission = ownerPermissionDto({aco_foreign_key: resource4.id});
+    delete resource4.secrets;
+    return [resource1, resource2, resource3, resource4];
+  });
+});
+
+describe("ResourceLocalStorageUpdateService", () => {
+  // mock data
+  const account = new AccountEntity(defaultAccountDto());
+  describe("ResourceLocalStorageUpdateService::getOrUpdateLocalStorage", () => {
+    it("Should find all resources and set the local storage and get it on second call", async() => {
+      expect.assertions(6);
+      const options = new ApiClientOptions().setBaseUrl('https://localhost');
+      const resourceLocalStorageUpdateService = new ResourceLocalStorageUpdateService(account, options);
+      let resources = await resourceLocalStorageUpdateService.exec();
+      const resourcesToCheckEquality = new ResourcesCollection(await ResourceLocalStorage.get());
+
+      expect(resourceLocalStorageUpdateService.resourceService.findAll).toHaveBeenCalledWith({permission: true, favorite: true, tag: true});
+      expect(resources.items.length).toBe(resourcesToCheckEquality.items.length);
+      expect(resources.toDto()).toStrictEqual(resourcesToCheckEquality.toDto());
+
+      resources = await resourceLocalStorageUpdateService.exec(false);
+      expect(resourceLocalStorageUpdateService.resourceService.findAll).toHaveBeenCalledTimes(1);
+      expect(resources.length).toBe(resourcesToCheckEquality.length);
+      expect(resources).toStrictEqual(resourcesToCheckEquality);
+    });
+
+    it("Should find all resources and set the local storage one time if it's not forced", async() => {
+      expect.assertions(2);
+      const options = new ApiClientOptions().setBaseUrl('https://localhost');
+      const resourceLocalStorageUpdateService = new ResourceLocalStorageUpdateService(account, options);
+
+      await resourceLocalStorageUpdateService.exec(true);
+      expect(resourceLocalStorageUpdateService.resourceService.findAll).toHaveBeenCalledWith({permission: true, favorite: true, tag: true});
+
+      jest.advanceTimersByTime(3000);
+
+      await resourceLocalStorageUpdateService.exec(true);
+      expect(resourceLocalStorageUpdateService.resourceService.findAll).toHaveBeenCalledTimes(1);
+    });
+
+    it("Should find all resources and set the local storage if the time is of the last called is more than 5000ms and forced", async() => {
+      expect.assertions(2);
+      const options = new ApiClientOptions().setBaseUrl('https://localhost');
+      const resourceLocalStorageUpdateService = new ResourceLocalStorageUpdateService(account, options);
+
+      await resourceLocalStorageUpdateService.exec(true);
+      expect(resourceLocalStorageUpdateService.resourceService.findAll).toHaveBeenCalledWith({permission: true, favorite: true, tag: true});
+
+      jest.advanceTimersByTime(5001);
+
+      await resourceLocalStorageUpdateService.exec(true);
+      expect(resourceLocalStorageUpdateService.resourceService.findAll).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  it("Should find all resources and set the local storage if the forceUpdate is true only once if the time is not overdue", async() => {
+    expect.assertions(2);
+    const options = new ApiClientOptions().setBaseUrl('https://localhost');
+    const resourceLocalStorageUpdateService = new ResourceLocalStorageUpdateService(account, options);
+
+    await resourceLocalStorageUpdateService.exec(true);
+    expect(resourceLocalStorageUpdateService.resourceService.findAll).toHaveBeenCalledWith({permission: true, favorite: true, tag: true});
+
+    await resourceLocalStorageUpdateService.exec(true);
+    expect(resourceLocalStorageUpdateService.resourceService.findAll).toHaveBeenCalledTimes(1);
+  });
+});

package/src/all/background_page/service/api/resource/resourceService.js

@@ -10,7 +10,7 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {AbstractService} = require('../abstract/abstractService');
+import AbstractService from "../abstract/abstractService";
 
 const RESOURCE_SERVICE_RESOURCE_NAME = 'resources';
 
@@ -98,7 +98,7 @@ class ResourceService extends AbstractService {
    */
   async get(id, contains) {
     this.assertValidId(id);
-    let options = contains ? this.formatContainOptions(contains, ResourceService.getSupportedContainOptions()) : null;
+    const options = contains ? this.formatContainOptions(contains, ResourceService.getSupportedContainOptions()) : null;
     const response = await this.apiClient.get(id, options);
     return response.body;
   }
@@ -136,7 +136,7 @@ class ResourceService extends AbstractService {
    */
   async create(data, contains) {
     this.assertNonEmptyData(data);
-    let options = contains ? this.formatContainOptions(contains, ResourceService.getSupportedContainOptions()) : null;
+    const options = contains ? this.formatContainOptions(contains, ResourceService.getSupportedContainOptions()) : null;
     const response = await this.apiClient.create(data, options);
     return response.body;
   }
@@ -154,7 +154,7 @@ class ResourceService extends AbstractService {
   async update(resourceId, resourceData, contains) {
     this.assertValidId(resourceId);
     this.assertNonEmptyData(resourceData);
-    let options = contains ? this.formatContainOptions(contains, ResourceService.getSupportedContainOptions()) : null;
+    const options = contains ? this.formatContainOptions(contains, ResourceService.getSupportedContainOptions()) : null;
     const response = await this.apiClient.update(resourceId, resourceData, options);
     return response.body;
   }
@@ -194,7 +194,7 @@ class ResourceService extends AbstractService {
       return resources;
     }
 
-    let url = this.apiClient.buildUrl(this.apiClient.baseUrl.toString());
+    const url = this.apiClient.buildUrl(this.apiClient.baseUrl.toString());
     resourcesIds.forEach(resourceId => {
       url.searchParams.append(`filter[has-id][]`, resourceId);
     });
@@ -208,4 +208,4 @@ class ResourceService extends AbstractService {
   }
 }
 
-exports.ResourceService = ResourceService;
+export default ResourceService;

package/src/all/background_page/service/api/resourceType/resourceTypeService.js

@@ -10,7 +10,7 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {AbstractService} = require('../abstract/abstractService');
+import AbstractService from "../abstract/abstractService";
 
 const RESOURCE_TYPES_SERVICE_RESOURCE_NAME = 'resource-types';
 
@@ -65,4 +65,4 @@ class ResourceTypeService extends AbstractService {
   }
 }
 
-exports.ResourceTypeService = ResourceTypeService;
+export default ResourceTypeService;

package/src/all/background_page/service/api/role/roleService.js

@@ -10,7 +10,7 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {AbstractService} = require('../abstract/abstractService');
+import AbstractService from "../abstract/abstractService";
 
 const ROLES_SERVICE_RESOURCE_NAME = 'roles';
 
@@ -51,4 +51,4 @@ class RoleService extends AbstractService {
   }
 }
 
-exports.RoleService = RoleService;
+export default RoleService;

package/src/all/background_page/service/api/setup/setupService.js

@@ -10,9 +10,9 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {PassboltBadResponseError} = require("../../../error/passboltBadResponseError");
-const {PassboltServiceUnavailableError} = require("../../../error/passboltServiceUnavailableError");
-const {AbstractService} = require('../abstract/abstractService');
+import PassboltBadResponseError from "../../../error/passboltBadResponseError";
+import AbstractService from "../abstract/abstractService";
+import PassboltServiceUnavailableError from "../../../error/passboltServiceUnavailableError";
 
 const SETUP_SERVICE_RESOURCE_NAME = 'setup';
 
@@ -52,15 +52,15 @@ class SetupService extends AbstractService {
   }
 
   /**
-   * Complete a recovery
+   * Complete a recover
    * @param {string} userId the user id
    * @param {object} completeDto The complete operation dto
    * @returns {Promise<*>} response body
    * @throws {Error} if options are invalid or API error
    */
-  async completeRecovery(userId, completeDto) {
+  async completeRecover(userId, completeDto) {
     this.assertValidId(userId);
-    const url = new URL(`${this.apiClient.baseUrl}/completeRecovery/${userId}`);
+    const url = new URL(`${this.apiClient.baseUrl}/recover/complete/${userId}`);
     const bodyString = this.apiClient.buildBody(completeDto);
     return this.apiClient.fetchAndHandleResponse('POST', url, bodyString);
   }
@@ -75,7 +75,7 @@ class SetupService extends AbstractService {
   async findSetupInfo(userId, token) {
     this.assertValidId(userId);
     this.assertValidId(token);
-    const url = this.apiClient.buildUrl(`${this.apiClient.baseUrl}/install/${userId}/${token}`, {});
+    const url = this.apiClient.buildUrl(`${this.apiClient.baseUrl}/start/${userId}/${token}`, {});
     const response = await this.apiClient.fetchAndHandleResponse('GET', url);
     return response.body;
   }
@@ -95,6 +95,21 @@ class SetupService extends AbstractService {
     return response.body;
   }
 
+  /**
+   * Abort recover.
+   * @param {string} userId the user id
+   * @param {object} abortDto the abort recover dto.
+   * @returns {Promise<*>} response body
+   * @throws {Error} if options are invalid or API error
+   */
+  async abort(userId, abortDto) {
+    this.assertValidId(userId);
+    const url = this.apiClient.buildUrl(`${this.apiClient.baseUrl}/recover/abort/${userId}`, {});
+    const bodyString = this.apiClient.buildBody(abortDto);
+    const response = await this.apiClient.fetchAndHandleResponse('POST', url, bodyString);
+    return response.body;
+  }
+
   /**
    * Find legacy setup info.
    * @param {string} userId the user id
@@ -112,25 +127,32 @@ class SetupService extends AbstractService {
     try {
       response = await fetch(url.toString());
     } catch (error) {
-      // Catch Network error such as connection lost.
-      throw new PassboltServiceUnavailableError(error.message);
+      if (navigator.onLine) {
+        // Catch Network error such as bad certificate or server unreachable.
+        throw new PassboltServiceUnavailableError("Unable to reach the server, an unexpected error occurred");
+      } else {
+        // Network connection lost.
+        throw new PassboltServiceUnavailableError("Unable to reach the server, you are not connected to the network");
+      }
     }
 
     try {
       responseHtml = await response.text();
-      let parser = new DOMParser();
-      let parsedHtml = parser.parseFromString(responseHtml, 'text/html');
+      const parser = new DOMParser();
+      const parsedHtml = parser.parseFromString(responseHtml, 'text/html');
       username = parsedHtml.getElementById('js_setup_user_username').value;
       firstName = parsedHtml.getElementById('js_setup_user_first_name').value;
       lastName = parsedHtml.getElementById('js_setup_user_last_name').value;
     } catch (error) {
-      // If the response cannot be parsed, it's not a Passbolt API response.
-      // It can be a for example a proxy timeout error (504).
+      /*
+       * If the response cannot be parsed, it's not a Passbolt API response.
+       * It can be a for example a proxy timeout error (504).
+       */
       throw new PassboltBadResponseError();
     }
 
     return {
-      username,
+      username: username,
       profile: {
         first_name: firstName,
         last_name: lastName
@@ -155,25 +177,32 @@ class SetupService extends AbstractService {
     try {
       response = await fetch(url.toString());
     } catch (error) {
-      // Catch Network error such as connection lost.
-      throw new PassboltServiceUnavailableError(error.message);
+      if (navigator.onLine) {
+        // Catch Network error such as bad certificate or server unreachable.
+        throw new PassboltServiceUnavailableError("Unable to reach the server, an unexpected error occurred");
+      } else {
+        // Network connection lost.
+        throw new PassboltServiceUnavailableError("Unable to reach the server, you are not connected to the network");
+      }
     }
 
     try {
       responseHtml = await response.text();
-      let parser = new DOMParser();
-      let parsedHtml = parser.parseFromString(responseHtml, 'text/html');
+      const parser = new DOMParser();
+      const parsedHtml = parser.parseFromString(responseHtml, 'text/html');
       username = parsedHtml.getElementById('js_setup_user_username').value;
       firstName = parsedHtml.getElementById('js_setup_user_first_name').value;
       lastName = parsedHtml.getElementById('js_setup_user_last_name').value;
     } catch (error) {
-      // If the response cannot be parsed, it's not a Passbolt API response.
-      // It can be a for example a proxy timeout error (504).
+      /*
+       * If the response cannot be parsed, it's not a Passbolt API response.
+       * It can be a for example a proxy timeout error (504).
+       */
       throw new PassboltBadResponseError();
     }
 
     return {
-      username,
+      username: username,
       profile: {
         first_name: firstName,
         last_name: lastName
@@ -182,4 +211,4 @@ class SetupService extends AbstractService {
   }
 }
 
-exports.SetupService = SetupService;
+export default SetupService;

package/src/all/background_page/service/api/share/shareService.js

@@ -10,7 +10,7 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {AbstractService} = require('../abstract/abstractService');
+import AbstractService from "../abstract/abstractService";
 
 const SHARE_SERVICE_RESOURCE_NAME = 'share';
 
@@ -47,10 +47,42 @@ class ShareService extends AbstractService {
   async shareFolder(folderId, permissionChangesDto) {
     this.assertValidId(folderId);
     this.assertNonEmptyData(permissionChangesDto);
-    let url = `folder/${folderId}`;
+    const url = `folder/${folderId}`;
     const response = await this.apiClient.update(url, permissionChangesDto);
     return response.body;
   }
+
+  /**
+   * Simulate share permissions update.
+   *
+   * It is helpful to :
+   *  - Ensure that the changes won't compromise the data integrity;
+   *  - Get the lists of added and removed users (Used for later encryption).
+   *
+   * @param resourceId
+   * @param permissions
+   * @returns {*}
+   */
+  async simulateShareResource(resourceId, permissions) {
+    const url = this.apiClient.buildUrl(`${this.apiClient.baseUrl}/simulate/resource/${resourceId}`, {});
+    const body = this.apiClient.buildBody({permissions: permissions});
+    const response = await this.apiClient.fetchAndHandleResponse('POST', url, body);
+    return response.body;
+  }
+
+  /**
+   * Share a resource
+   * @param {string} resourceId The resource id to share
+   * @param {object} data The request body data
+   * @returns {*}
+   */
+  async shareResource(resourceId, data) {
+    this.assertValidId(resourceId);
+    this.assertNonEmptyData(data);
+    const url = `resource/${resourceId}`;
+    const response = await this.apiClient.update(url, data);
+    return response.body;
+  }
 }
 
-exports.ShareService = ShareService;
+export default ShareService;