passbolt-browser-extension 5.12.1 → 5.13.0

package/src/all/background_page/service/group/getOrFindGroupsService.js

@@ -0,0 +1,65 @@
+/**
+ * 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         5.13.0
+ */
+import FindAndUpdateGroupsLocalStorageService from "./findAndUpdateGroupsLocalStorageService";
+import GroupLocalStorage from "../local_storage/groupLocalStorage";
+import GroupsCollection from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection";
+import { assertArrayUUID } from "../../utils/assertions";
+
+/**
+ * The service aims to get groups from the local storage if it is set, or retrieve them from the API and
+ * set the local storage.
+ */
+export default class GetOrFindGroupsService {
+  /**
+   *
+   * @param {AccountEntity} account The user account
+   * @param {ApiClientOptions} apiClientOptions The api client options
+   */
+  constructor(account, apiClientOptions) {
+    this.account = account;
+    this.groupLocalStorage = new GroupLocalStorage(account);
+    this.findAndUpdateGroupsLocalStorage = new FindAndUpdateGroupsLocalStorageService(account, apiClientOptions);
+  }
+
+  /**
+   * Get or find all groups.
+   * @returns {Promise<GroupsCollection>}
+   */
+  async getOrFindAll() {
+    const hasRuntimeCache = GroupLocalStorage.hasCachedData(this.account.id);
+    const groupsDto = await this.groupLocalStorage.get();
+    // Return local storage data if the storage was initialized.
+    if (groupsDto) {
+      // No validation is required if the data is in the runtime cache, as validation was done by the process that set the cache.
+      return new GroupsCollection(groupsDto, { validate: !hasRuntimeCache });
+    }
+
+    // Otherwise retrieve the groups and update the local storage.
+    return this.findAndUpdateGroupsLocalStorage.findAndUpdateAll();
+  }
+
+  /**
+   * Get or find all the groups matching the given ids.
+   * @param {Array<string>} groupIds The groups to find.
+   * @return {Promise<GroupsCollection>}
+   */
+  async getOrFindByIds(groupIds) {
+    assertArrayUUID(groupIds);
+
+    const groupsCollection = await this.getOrFindAll();
+    groupsCollection.filterByPropertyValueIn("id", groupIds);
+
+    return groupsCollection;
+  }
+}

package/src/all/background_page/service/group/getOrFindGroupsService.test.js

@@ -0,0 +1,168 @@
+/**
+ * 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         5.13.0
+ */
+
+import { v4 as uuidv4 } from "uuid";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
+import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import GetOrFindGroupsService from "./getOrFindGroupsService";
+import FindAndUpdateGroupsLocalStorageService from "./findAndUpdateGroupsLocalStorageService";
+import FindGroupsService from "./findGroupsService";
+import GroupsCollection from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection";
+import GroupLocalStorage from "../local_storage/groupLocalStorage";
+import { defaultGroupsDtos } from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection.test.data";
+
+describe("GetOrFindGroupsService", () => {
+  let service, account;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    account = new AccountEntity(defaultAccountDto());
+    service = new GetOrFindGroupsService(account, defaultApiClientOptions());
+    // flush account related storage before each.
+    await service.groupLocalStorage.flush();
+  });
+
+  describe("::getOrFindAll", () => {
+    it("fetches from the API and initializes the local storage with an empty array when the API returns no groups.", async () => {
+      expect.assertions(4);
+      jest
+        .spyOn(FindGroupsService.prototype, "findAllForLocalStorage")
+        .mockImplementation(() => new GroupsCollection([]));
+      jest.spyOn(FindAndUpdateGroupsLocalStorageService.prototype, "findAndUpdateAll");
+
+      const groups = await service.getOrFindAll();
+
+      expect(FindAndUpdateGroupsLocalStorageService.prototype.findAndUpdateAll).toHaveBeenCalledTimes(1);
+      expect(groups).toBeInstanceOf(GroupsCollection);
+      expect(groups).toHaveLength(0);
+      expect(await service.groupLocalStorage.get()).toEqual([]);
+    });
+
+    it("fetches the groups from the API and populates the local storage when the local storage is not initialized.", async () => {
+      expect.assertions(4);
+      const groupsDto = defaultGroupsDtos();
+      jest
+        .spyOn(FindGroupsService.prototype, "findAllForLocalStorage")
+        .mockImplementation(() => new GroupsCollection(groupsDto));
+
+      const groups = await service.getOrFindAll();
+
+      expect(groups).toHaveLength(groupsDto.length);
+      expect(groups.toDto(GroupLocalStorage.DEFAULT_CONTAIN)).toEqual(groupsDto);
+      expect(GroupLocalStorage.hasCachedData(account.id)).toBeTruthy();
+      expect(await service.groupLocalStorage.get()).toEqual(groupsDto);
+    });
+
+    it("retrieves groups from the local storage when the local storage is initialized.", async () => {
+      expect.assertions(5);
+      const groupsDto = defaultGroupsDtos();
+      jest.spyOn(FindGroupsService.prototype, "findAllForLocalStorage");
+      await service.groupLocalStorage.set(new GroupsCollection(groupsDto));
+
+      const groups = await service.getOrFindAll();
+
+      expect(FindGroupsService.prototype.findAllForLocalStorage).not.toHaveBeenCalled();
+      expect(groups).toHaveLength(groupsDto.length);
+      expect(groups.toDto(GroupLocalStorage.DEFAULT_CONTAIN)).toEqual(groupsDto);
+      expect(GroupLocalStorage.hasCachedData(account.id)).toBeTruthy();
+      expect(await service.groupLocalStorage.get()).toEqual(groupsDto);
+    });
+
+    it("does not validate the groups collection if the information is retrieved from the runtime cache.", async () => {
+      expect.assertions(2);
+      jest.spyOn(FindGroupsService.prototype, "findAllForLocalStorage");
+      await service.groupLocalStorage.set(new GroupsCollection(defaultGroupsDtos()));
+      jest.spyOn(GroupsCollection.prototype, "validateSchema");
+
+      await service.getOrFindAll();
+
+      expect(FindGroupsService.prototype.findAllForLocalStorage).not.toHaveBeenCalled();
+      // Validation must not be triggered by getOrFindAll when the data comes from the runtime cache.
+      expect(GroupsCollection.prototype.validateSchema).not.toHaveBeenCalled();
+    });
+
+    it("validates groups collection if the local storage has no runtime cache and the information is retrieved from the local storage.", async () => {
+      expect.assertions(2);
+      jest.spyOn(FindGroupsService.prototype, "findAllForLocalStorage");
+      await service.groupLocalStorage.set(new GroupsCollection(defaultGroupsDtos()));
+      delete GroupLocalStorage._runtimeCachedData[account.id];
+      jest.spyOn(GroupsCollection.prototype, "validateSchema");
+
+      await service.getOrFindAll();
+
+      expect(FindGroupsService.prototype.findAllForLocalStorage).not.toHaveBeenCalled();
+      // Validation must be triggered by getOrFindAll when the data is loaded from the disk cache.
+      expect(GroupsCollection.prototype.validateSchema).toHaveBeenCalled();
+    });
+  });
+
+  describe("::getOrFindByIds", () => {
+    it("returns only the groups whose ids are in the requested set.", async () => {
+      expect.assertions(2);
+      const groupsDto = defaultGroupsDtos();
+      await service.groupLocalStorage.set(new GroupsCollection(groupsDto));
+      const requestedIds = [groupsDto[1].id, groupsDto[3].id, groupsDto[5].id];
+
+      const groups = await service.getOrFindByIds(requestedIds);
+
+      expect(groups).toHaveLength(3);
+      expect(groups.extract("id").sort()).toEqual([...requestedIds].sort());
+    });
+
+    it("returns an empty collection when none of the ids match.", async () => {
+      expect.assertions(1);
+      const groupsDto = defaultGroupsDtos();
+      await service.groupLocalStorage.set(new GroupsCollection(groupsDto));
+
+      const groups = await service.getOrFindByIds([uuidv4(), uuidv4()]);
+
+      expect(groups).toHaveLength(0);
+    });
+
+    it("returns all groups when every group id is requested.", async () => {
+      expect.assertions(2);
+      const groupsDto = defaultGroupsDtos();
+      await service.groupLocalStorage.set(new GroupsCollection(groupsDto));
+      const allIds = groupsDto.map((group) => group.id);
+
+      const groups = await service.getOrFindByIds(allIds);
+
+      expect(groups).toHaveLength(groupsDto.length);
+      expect(groups.extract("id").sort()).toEqual([...allIds].sort());
+    });
+
+    it("fetches from the API when the local storage is not initialized, then filters.", async () => {
+      expect.assertions(3);
+      const groupsDto = defaultGroupsDtos();
+      jest
+        .spyOn(FindGroupsService.prototype, "findAllForLocalStorage")
+        .mockImplementation(() => new GroupsCollection(groupsDto));
+      const requestedIds = [groupsDto[0].id, groupsDto[2].id];
+
+      const groups = await service.getOrFindByIds(requestedIds);
+
+      expect(FindGroupsService.prototype.findAllForLocalStorage).toHaveBeenCalledTimes(1);
+      expect(groups).toHaveLength(2);
+      expect(groups.extract("id").sort()).toEqual([...requestedIds].sort());
+    });
+
+    it("should assert its parameter.", async () => {
+      expect.assertions(1);
+      await expect(() => service.getOrFindByIds(["not-a-uuid"])).rejects.toThrow(
+        "The given parameter is not a valid array of uuid",
+      );
+    });
+  });
+});

package/src/all/background_page/service/group/getOrFindGroupsUsersService.js

@@ -0,0 +1,51 @@
+/**
+ * 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         5.13.0
+ */
+import GroupsUsersCollection from "passbolt-styleguide/src/shared/models/entity/groupUser/groupsUsersCollection";
+import GetOrFindGroupsService from "./getOrFindGroupsService";
+import { assertUuid } from "../../utils/assertions";
+
+/**
+ * The service aims to retrieve the group members of a given group from the local storage cache
+ * served by `GetOrFindGroupsService`, falling back to the API on a cold cache.
+ */
+class GetOrFindGroupsUsersService {
+  /**
+   * Constructor.
+   * @param {AccountEntity} account The user account.
+   * @param {ApiClientOptions} apiClientOptions The api client options.
+   */
+  constructor(account, apiClientOptions) {
+    this.getOrFindGroupsService = new GetOrFindGroupsService(account, apiClientOptions);
+  }
+
+  /**
+   * Get or find the members of the group matching the given id.
+   * @param {string} groupId The id of the group whose members are requested.
+   * @returns {Promise<GroupsUsersCollection>}
+   * @throws {Error} If no group is found for the given id.
+   */
+  async getOrFindByGroupId(groupId) {
+    assertUuid(groupId);
+
+    const groupsCollection = await this.getOrFindGroupsService.getOrFindAll();
+    const group = groupsCollection.getFirst("id", groupId);
+    if (!group) {
+      throw new Error(`The group with id ${groupId} could not be found.`);
+    }
+
+    return group.groupsUsers ?? new GroupsUsersCollection([]);
+  }
+}
+
+export default GetOrFindGroupsUsersService;

package/src/all/background_page/service/group/getOrFindGroupsUsersService.test.js

@@ -0,0 +1,94 @@
+/**
+ * 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         5.13.0
+ */
+
+import { v4 as uuidv4 } from "uuid";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
+import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import GetOrFindGroupsUsersService from "./getOrFindGroupsUsersService";
+import FindGroupsService from "./findGroupsService";
+import GroupsCollection from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection";
+import GroupsUsersCollection from "passbolt-styleguide/src/shared/models/entity/groupUser/groupsUsersCollection";
+import { defaultGroupsDtos } from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection.test.data";
+
+describe("GetOrFindGroupsUsersService", () => {
+  let service, account;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    account = new AccountEntity(defaultAccountDto());
+    service = new GetOrFindGroupsUsersService(account, defaultApiClientOptions());
+    // flush account related storage before each.
+    await service.getOrFindGroupsService.groupLocalStorage.flush();
+  });
+
+  describe("::getOrFindByGroupId", () => {
+    it("returns the members of the requested group when the local storage is populated.", async () => {
+      expect.assertions(3);
+      const groupsDto = defaultGroupsDtos(5, { withGroupsUsers: 3 });
+      await service.getOrFindGroupsService.groupLocalStorage.set(new GroupsCollection(groupsDto));
+      const targetGroup = groupsDto[2];
+
+      const result = await service.getOrFindByGroupId(targetGroup.id);
+
+      expect(result).toBeInstanceOf(GroupsUsersCollection);
+      expect(result).toHaveLength(3);
+      expect(result.items.every((groupUser) => groupUser.groupId === targetGroup.id)).toBe(true);
+    });
+
+    it("returns an empty GroupsUsersCollection when the group has no members.", async () => {
+      expect.assertions(2);
+      const groupsDto = defaultGroupsDtos(1, { withGroupsUsers: 0 });
+      await service.getOrFindGroupsService.groupLocalStorage.set(new GroupsCollection(groupsDto));
+
+      const result = await service.getOrFindByGroupId(groupsDto[0].id);
+
+      expect(result).toBeInstanceOf(GroupsUsersCollection);
+      expect(result).toHaveLength(0);
+    });
+
+    it("fetches from the API when the local storage is not initialized, then returns the requested group's members.", async () => {
+      expect.assertions(3);
+      const groupsDto = defaultGroupsDtos(3, { withGroupsUsers: 2 });
+      jest
+        .spyOn(FindGroupsService.prototype, "findAllForLocalStorage")
+        .mockImplementation(() => new GroupsCollection(groupsDto));
+      const targetGroup = groupsDto[1];
+
+      const result = await service.getOrFindByGroupId(targetGroup.id);
+
+      expect(FindGroupsService.prototype.findAllForLocalStorage).toHaveBeenCalledTimes(1);
+      expect(result).toBeInstanceOf(GroupsUsersCollection);
+      expect(result).toHaveLength(2);
+    });
+
+    it("throws when the group id does not exist.", async () => {
+      expect.assertions(1);
+      const groupsDto = defaultGroupsDtos();
+      await service.getOrFindGroupsService.groupLocalStorage.set(new GroupsCollection(groupsDto));
+      const missingId = uuidv4();
+
+      await expect(() => service.getOrFindByGroupId(missingId)).rejects.toThrow(
+        `The group with id ${missingId} could not be found.`,
+      );
+    });
+
+    it("should assert its parameter.", async () => {
+      expect.assertions(1);
+      await expect(() => service.getOrFindByGroupId("not-a-uuid")).rejects.toThrow(
+        "The given parameter is not a valid UUID",
+      );
+    });
+  });
+});

package/src/all/background_page/service/group/groupUpdateService.js

@@ -16,7 +16,7 @@ import Keyring from "../../model/keyring";
 import EncryptMessageService from "../../service/crypto/encryptMessageService";
 import DecryptMessageService from "../../service/crypto/decryptMessageService";
 import GroupModel from "../../model/group/groupModel";
-import GroupEntity from "../../model/entity/group/groupEntity";
+import GroupEntity from "passbolt-styleguide/src/shared/models/entity/group/groupEntity";
 import GroupUpdateEntity from "../../model/entity/group/update/groupUpdateEntity";
 import i18n from "../../sdk/i18n";
 import SecretEntity from "passbolt-styleguide/src/shared/models/entity/secret/secretEntity";
@@ -37,7 +37,7 @@ import GroupApiService from "../api/group/groupApiService";
  * - Done
  */
 const PROGRESS_GOAL = 6;
-const YIELD_INTERVAL_MS = 25000; // yield avant 30s pour avoir une marge
+const YIELD_INTERVAL_MS = 8000; // PB-51648 yield reduce to 8s due to chrome 148 more strict to ping service worker
 
 class GroupUpdateService {
   /**
@@ -216,7 +216,9 @@ class GroupUpdateService {
 
       this.progressService.updateStepMessage(progressMessage);
       const groupUpdateOperation = groupUpdateSingleOperationList.items[i];
-      const groupDto = await this.groupApiService.update(groupUpdateOperation.id, groupUpdateOperation.toDto());
+      const groupDto = await this.groupApiService.update(groupUpdateOperation.id, groupUpdateOperation.toDto(), {
+        my_group_user: true,
+      });
       const updatedGroupEntity = new GroupEntity(groupDto, { ignoreInvalidEntity: true });
       await this.groupLocalStorage.updateGroup(updatedGroupEntity);
     }

package/src/all/background_page/service/group/groupUpdateService.test.js

@@ -12,7 +12,7 @@
  * @since         4.10.1
  */
 import GroupUpdateService from "./groupUpdateService";
-import GroupEntity from "../../model/entity/group/groupEntity";
+import GroupEntity from "passbolt-styleguide/src/shared/models/entity/group/groupEntity";
 import GroupUpdateEntity from "../../model/entity/group/update/groupUpdateEntity";
 import GroupUpdateDryRunResultEntity from "../../model/entity/group/update/groupUpdateDryRunResultEntity";
 import EncryptMessageService from "../crypto/encryptMessageService";
@@ -89,7 +89,11 @@ describe("GroupUpdateService", () => {
     expect(spyOnGroupApiServiceUpdate).toHaveBeenCalledTimes(1);
     const expectedDiffGropuUpdateEntityDto = diffGroupUpdateEntity.toDto();
     delete expectedDiffGropuUpdateEntityDto.groups_users;
-    expect(spyOnGroupApiServiceUpdate).toHaveBeenCalledWith(diffGroupUpdateEntity.id, expectedDiffGropuUpdateEntityDto);
+    expect(spyOnGroupApiServiceUpdate).toHaveBeenCalledWith(
+      diffGroupUpdateEntity.id,
+      expectedDiffGropuUpdateEntityDto,
+      { my_group_user: true },
+    );
 
     //Exepctation for the progressSerivce when there is no crypto involved
     expect(progressService.start).toHaveBeenCalledTimes(1);
@@ -171,10 +175,12 @@ describe("GroupUpdateService", () => {
     expect(spyOnGroupApiServiceUpdate).toHaveBeenCalledWith(
       diffGroupUpdateEntity.id,
       expectedDiffGropuUpdateEntityDto1,
+      { my_group_user: true },
     );
     expect(spyOnGroupApiServiceUpdate).toHaveBeenCalledWith(
       diffGroupUpdateEntity.id,
       expectedDiffGropuUpdateEntityDto2,
+      { my_group_user: true },
     );
   });
 
@@ -243,10 +249,12 @@ describe("GroupUpdateService", () => {
     expect(spyOnGroupApiServiceUpdate).toHaveBeenCalledWith(
       diffGroupUpdateEntity.id,
       expectedDiffGropuUpdateEntityDto1,
+      { my_group_user: true },
     );
     expect(spyOnGroupApiServiceUpdate).toHaveBeenCalledWith(
       diffGroupUpdateEntity.id,
       expectedDiffGropuUpdateEntityDto2,
+      { my_group_user: true },
     );
   });
 

package/src/all/background_page/service/local_storage/groupLocalStorage.js

@@ -12,8 +12,8 @@
  * @since         2.13.0
  */
 import Log from "../../model/log";
-import GroupsCollection from "../../model/entity/group/groupsCollection";
-import GroupEntity from "../../model/entity/group/groupEntity";
+import GroupsCollection from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection";
+import GroupEntity from "passbolt-styleguide/src/shared/models/entity/group/groupEntity";
 import AccountEntity from "../../model/entity/account/accountEntity";
 
 export const GROUP_LOCAL_STORAGE_KEY = "groups";

package/src/all/background_page/service/local_storage/groupLocalStorage.test.js

@@ -14,10 +14,10 @@
 import { defaultGroupDto } from "passbolt-styleguide/src/shared/models/entity/group/groupEntity.test.data";
 import AccountEntity from "../../model/entity/account/accountEntity";
 import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
-import GroupsCollection from "../../model/entity/group/groupsCollection";
-import { defaultGroupsDtos } from "../../model/entity/group/groupsCollection.test.data";
+import GroupsCollection from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection";
+import { defaultGroupsDtos } from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection.test.data";
 import GroupLocalStorage from "./groupLocalStorage";
-import GroupEntity from "../../model/entity/group/groupEntity";
+import GroupEntity from "passbolt-styleguide/src/shared/models/entity/group/groupEntity";
 
 beforeEach(() => {
   jest.clearAllMocks();

package/src/all/background_page/service/local_storage/userLocalStorage.js

@@ -12,14 +12,27 @@
  * @since         2.13.0
  */
 import Log from "../../model/log";
-import UserEntity from "../../model/entity/user/userEntity";
-import UsersCollection from "../../model/entity/user/usersCollection";
-import Lock from "../../utils/lock";
-const lock = new Lock();
+import UserEntity from "passbolt-styleguide/src/shared/models/entity/user/userEntity";
+import UsersCollection from "passbolt-styleguide/src/shared/models/entity/user/usersCollection";
 
 const USER_LOCAL_STORAGE_KEY = "users";
 
 class UserLocalStorage {
+  /**
+   * Runtime cached data.
+   * @type {Array|null}
+   * @private
+   */
+  static _runtimeCachedData = null;
+
+  /**
+   * Check if there is cached data.
+   * @returns {boolean}
+   */
+  static hasCachedData() {
+    return UserLocalStorage._runtimeCachedData !== null && UserLocalStorage._runtimeCachedData !== undefined;
+  }
+
   /**
    * Flush the users local storage
    *
@@ -27,40 +40,50 @@ class UserLocalStorage {
    * @return {Promise<void>}
    */
   static async flush() {
+    UserLocalStorage._runtimeCachedData = null;
     Log.write({ level: "debug", message: "UserLocalStorage flushed" });
     return await browser.storage.local.remove(UserLocalStorage.USER_LOCAL_STORAGE_KEY);
   }
 
   /**
-   * Set the users local storage.
+   * Get the users from the local storage.
    *
    * @throws {Error} if operation failed
    * @return {Promise} results object, containing every object in keys that was found in the storage area.
    * If storage is not set, undefined will be returned.
    */
   static async get() {
+    if (UserLocalStorage._runtimeCachedData) {
+      return UserLocalStorage._runtimeCachedData;
+    }
     const { users } = await browser.storage.local.get([UserLocalStorage.USER_LOCAL_STORAGE_KEY]);
-    return users;
+    if (!users) {
+      return undefined;
+    }
+    UserLocalStorage._runtimeCachedData = users;
+    return UserLocalStorage._runtimeCachedData;
   }
 
   /**
    * Set the users local storage.
    *
    * @param {UsersCollection} usersCollection The users to insert in the local storage.
-   * @return {void}
+   * @return {Promise<void>}
    */
   static async set(usersCollection) {
-    await lock.acquire();
-    const users = [];
     if (!(usersCollection instanceof UsersCollection)) {
       throw new TypeError("UserLocalStorage::set expects a UsersCollection");
     }
-    for (const userEntity of usersCollection) {
-      UserLocalStorage.assertEntityBeforeSave(userEntity);
-      users.push(userEntity.toDto(UserLocalStorage.DEFAULT_CONTAIN));
-    }
-    await browser.storage.local.set({ users: users });
-    lock.release();
+
+    await navigator.locks.request(USER_LOCAL_STORAGE_KEY, async () => {
+      const users = [];
+      for (const userEntity of usersCollection) {
+        UserLocalStorage.assertEntityBeforeSave(userEntity);
+        users.push(userEntity.toDto(UserLocalStorage.DEFAULT_CONTAIN));
+      }
+      await browser.storage.local.set({ users: users });
+      UserLocalStorage._runtimeCachedData = users;
+    });
   }
 
   /**
@@ -77,30 +100,35 @@ class UserLocalStorage {
   /**
    * Add a user in the local storage
    * @param {UserEntity} userEntity
+   * @throws {TypeError} If parameter userEntity is not of type UserEntity.
    */
   static async addUser(userEntity) {
-    await lock.acquire();
-    try {
+    if (!userEntity || !(userEntity instanceof UserEntity)) {
+      throw new TypeError("UserLocalStorage expects an object of type UserEntity");
+    }
+
+    await navigator.locks.request(USER_LOCAL_STORAGE_KEY, async () => {
       UserLocalStorage.assertEntityBeforeSave(userEntity);
       const users = await UserLocalStorage.get();
       users.push(userEntity.toDto(UserLocalStorage.DEFAULT_CONTAIN));
       await browser.storage.local.set({ users: users });
-      lock.release();
-    } catch (error) {
-      lock.release();
-      throw error;
-    }
+      UserLocalStorage._runtimeCachedData = users;
+    });
   }
 
   /**
    * Update a user in the local storage.
    *
    * @param {UserEntity} userEntity The user to update
+   * @throws {TypeError} If parameter userEntity is not of type UserEntity.
    * @throws {Error} if the user does not exist in the local storage
    */
   static async updateUser(userEntity) {
-    await lock.acquire();
-    try {
+    if (!userEntity || !(userEntity instanceof UserEntity)) {
+      throw new TypeError("UserLocalStorage expects an object of type UserEntity");
+    }
+
+    await navigator.locks.request(USER_LOCAL_STORAGE_KEY, async () => {
       UserLocalStorage.assertEntityBeforeSave(userEntity);
       const users = await UserLocalStorage.get();
       // If the local storage has been already initialized.
@@ -111,12 +139,9 @@ class UserLocalStorage {
         }
         users[userIndex] = Object.assign(users[userIndex], userEntity.toDto(UserLocalStorage.DEFAULT_CONTAIN));
         await browser.storage.local.set({ users: users });
+        UserLocalStorage._runtimeCachedData = users;
       }
-      lock.release();
-    } catch (error) {
-      lock.release();
-      throw error;
-    }
+    });
   }
 
   /**
@@ -124,8 +149,7 @@ class UserLocalStorage {
    * @param {string} userId user uuid
    */
   static async delete(userId) {
-    await lock.acquire();
-    try {
+    await navigator.locks.request(USER_LOCAL_STORAGE_KEY, async () => {
       const users = await UserLocalStorage.get();
       if (users) {
         const userIndex = users.findIndex((item) => item.id === userId);
@@ -133,12 +157,9 @@ class UserLocalStorage {
           users.splice(userIndex, 1);
         }
         await browser.storage.local.set({ users: users });
-        lock.release();
+        UserLocalStorage._runtimeCachedData = users;
       }
-    } catch (error) {
-      lock.release();
-      throw error;
-    }
+    });
   }
 
   /**