passbolt-browser-extension 5.13.0 → 5.14.2

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

@@ -30,6 +30,9 @@ import GroupUserEntity from "passbolt-styleguide/src/shared/models/entity/groupU
 import { plaintextSecretPasswordAndDescriptionDto } from "passbolt-styleguide/src/shared/models/entity/plaintextSecret/plaintextSecretEntity.test.data";
 import GroupLocalStorage from "../local_storage/groupLocalStorage";
 import { defaultProgressService } from "../progress/progressService.test.data";
+import { RequestAddUsersToGroupOffscreenService } from "../../../../chrome-mv3/serviceWorker/service/addUsersToGroup/requestAddUsersToGroupOffscreenService";
+import GroupUpdateSecretsCollection from "../../model/entity/secret/groupUpdate/groupUpdateSecretsCollection";
+import SecretEntity from "passbolt-styleguide/src/shared/models/entity/secret/secretEntity";
 
 beforeEach(() => {
   jest.resetAllMocks();
@@ -261,6 +264,8 @@ describe("GroupUpdateService", () => {
   it("should update the group and encrypt secrets for the new users", async () => {
     expect.assertions(30);
 
+    chrome.runtime.getManifest.mockImplementation(() => ({ manifest_version: 2 }));
+
     const apiClientOptions = defaultApiClientOptions();
     const account = new AccountEntity(defaultAccountDto());
     const progressService = defaultProgressService({ goals: 10 });
@@ -369,6 +374,137 @@ describe("GroupUpdateService", () => {
     expect(progressService.updateStepMessage).toHaveBeenCalledWith("Updating group member 1/1");
   });
 
+  it("should update the group and encrypt secrets for the new users with offscreen", async () => {
+    expect.assertions(28);
+
+    chrome.runtime.getManifest.mockImplementation(() => ({ manifest_version: 3 }));
+
+    const apiClientOptions = defaultApiClientOptions();
+    const account = new AccountEntity(defaultAccountDto());
+    const progressService = defaultProgressService({ goals: 10 });
+
+    const existingEntityDto = defaultGroupDto({}, { withGroupsUsers: 1 });
+    const updateGroupEntity = new GroupEntity({ ...existingEntityDto });
+
+    const newUser = new GroupUserEntity(createGroupUser({ group_id: existingEntityDto.id }));
+    updateGroupEntity._groups_users._items = [...updateGroupEntity._groups_users.items, newUser];
+
+    const mixGroupUpdateDto = {
+      ...existingEntityDto,
+      groups_users: [
+        {
+          user_id: newUser._props.user_id,
+          is_admin: newUser._props.is_admin,
+        },
+      ],
+    };
+
+    const secrets = defaultResourcesSecretsDtos(1);
+
+    const adaPublicKey = await OpenpgpAssertion.readKeyOrFail(pgpKeys.ada.public);
+    const originalDecryptedSecret = plaintextSecretPasswordAndDescriptionDto();
+    secrets[0].data = await EncryptMessageService.encrypt(JSON.stringify(originalDecryptedSecret), adaPublicKey);
+    const needed_secrets = [
+      {
+        user_id: newUser._props.user_id,
+        resource_id: secrets[0].resource_id,
+      },
+    ];
+    const bettyPublicKey = await OpenpgpAssertion.readKeyOrFail(pgpKeys.betty.public);
+    const secretsBettyEncrypted = await EncryptMessageService.encrypt(
+      JSON.stringify(originalDecryptedSecret),
+      bettyPublicKey,
+    );
+    const secretBettyEntity = new SecretEntity({
+      user_id: newUser._props.user_id,
+      resource_id: secrets[0].resource_id,
+      data: secretsBettyEncrypted,
+    });
+    const groupUpdateDryRunResultDto = { needed_secrets, secrets };
+    const groupUpdateDryRunResultEntity = new GroupUpdateDryRunResultEntity(groupUpdateDryRunResultDto);
+    const diffGroupUpdateEntity = new GroupUpdateEntity(mixGroupUpdateDto);
+
+    const service = new GroupUpdateService(apiClientOptions, account, progressService);
+
+    const spyOnGroupModelGetById = jest.spyOn(service.groupModel, "getById");
+    const spyOnGroupModelDryRun = jest.spyOn(service.groupModel, "updateDryRun");
+    const spyOnGroupApiServiceUpdate = jest.spyOn(service.groupApiService, "update");
+    const spyOnKeyringSync = jest.spyOn(Keyring.prototype, "sync");
+    const spyOnKeyringFindPublic = jest.spyOn(Keyring.prototype, "findPublic");
+    const spyOnOffscreen = jest.spyOn(RequestAddUsersToGroupOffscreenService, "decryptAndEncryptSecrets");
+    jest.spyOn(GroupLocalStorage.prototype, "updateGroup").mockImplementation(() => {});
+
+    spyOnGroupModelGetById.mockImplementation(async () => new GroupEntity(existingEntityDto));
+    spyOnKeyringSync.mockImplementation(async () => {});
+    spyOnKeyringFindPublic.mockImplementation(() => ({ armoredKey: pgpKeys.betty.public }));
+    spyOnOffscreen.mockImplementationOnce(() => new GroupUpdateSecretsCollection([secretBettyEntity]));
+
+    spyOnGroupApiServiceUpdate.mockImplementation(async (groupUpdateId, groupUpdateDto) => {
+      if (!groupUpdateDto.groups_users) {
+        //it's the first step and  a group name update only operation
+        expect(groupUpdateDto.id).toStrictEqual(diffGroupUpdateEntity.id);
+        expect(groupUpdateDto.name).toStrictEqual(diffGroupUpdateEntity.name);
+        return groupUpdateDto; // ignoring first step
+      }
+
+      expect(groupUpdateId).toStrictEqual(diffGroupUpdateEntity.id);
+      expect(groupUpdateDto.id).toStrictEqual(diffGroupUpdateEntity.id);
+      expect(groupUpdateDto.name).toStrictEqual(diffGroupUpdateEntity.name);
+      expect(groupUpdateDto.groups_users).toStrictEqual(diffGroupUpdateEntity.groupsUsers.toDto());
+      expect(groupUpdateDto.secrets).toHaveLength(1);
+
+      const secret = groupUpdateDto.secrets[0];
+      expect(secret.resource_id).toStrictEqual(secrets[0].resource_id);
+      expect(secret.user_id).toStrictEqual(newUser._props.user_id);
+
+      const decryptedData = await DecryptMessageService.decrypt(
+        await OpenpgpAssertion.readMessageOrFail(secret.data),
+        await OpenpgpAssertion.readKeyOrFail(pgpKeys.betty.private_decrypted),
+      );
+      expect(JSON.parse(decryptedData)).toStrictEqual(originalDecryptedSecret);
+
+      return groupUpdateDto;
+    });
+
+    spyOnGroupModelDryRun.mockImplementation(async (groupUpdateEntity) => {
+      expect(groupUpdateEntity).toStrictEqual(diffGroupUpdateEntity);
+      return groupUpdateDryRunResultEntity;
+    });
+
+    await service.exec(updateGroupEntity, "ada@passbolt.com");
+
+    expect(spyOnKeyringSync).toHaveBeenCalledTimes(1);
+    expect(spyOnKeyringFindPublic).toHaveBeenCalledWith(newUser._props.user_id);
+
+    expect(spyOnGroupModelGetById).toHaveBeenCalledTimes(1);
+    expect(spyOnGroupModelGetById).toHaveBeenCalledWith(updateGroupEntity.id);
+
+    expect(spyOnGroupModelDryRun).toHaveBeenCalledTimes(1);
+
+    expect(spyOnGroupApiServiceUpdate).toHaveBeenCalledTimes(2);
+
+    expect(spyOnOffscreen).toHaveBeenCalledTimes(1);
+    expect(spyOnOffscreen).toHaveBeenCalledWith(
+      account,
+      "ada@passbolt.com",
+      groupUpdateDryRunResultEntity,
+      { [newUser._props.user_id]: pgpKeys.betty.public },
+      progressService,
+    );
+
+    //Exepctation for the progressSerivce when there is no crypto involved
+    expect(progressService.start).toHaveBeenCalledTimes(1);
+    expect(progressService.start).toHaveBeenCalledWith(6, "Initialize");
+    expect(progressService.updateGoals).not.toHaveBeenCalled();
+
+    expect(progressService.finishStep).toHaveBeenCalledTimes(5);
+    expect(progressService.finishStep).toHaveBeenCalledWith("Group update feasibility check", true);
+    expect(progressService.finishStep).toHaveBeenCalledWith("Encrypt required secrets for new users", true);
+    expect(progressService.finishStep).toHaveBeenCalledWith("Synchronizing keyring", true);
+    expect(progressService.finishStep).toHaveBeenCalledWith("Updating group", true);
+    expect(progressService.finishStep).toHaveBeenCalledWith("Done", true);
+  });
+
   it("should throw an error if the given dto is not valid as a GroupEntity", async () => {
     expect.assertions(1);
 

package/src/all/background_page/service/localStorage/localStorageService.js

@@ -14,7 +14,6 @@
 import ResourceLocalStorage from "../local_storage/resourceLocalStorage";
 import ResourceTypeLocalStorage from "../local_storage/resourceTypeLocalStorage";
 import FolderLocalStorage from "../local_storage/folderLocalStorage";
-import AuthStatusLocalStorage from "../local_storage/authStatusLocalStorage";
 import UserLocalStorage from "../local_storage/userLocalStorage";
 import GroupLocalStorage from "../local_storage/groupLocalStorage";
 import RolesLocalStorage from "../local_storage/rolesLocalStorage";
@@ -24,7 +23,6 @@ import PassphraseStorageService from "../session_storage/passphraseStorageServic
 import SsoKitTemporaryStorageService from "../session_storage/ssoKitTemporaryStorageService";
 import GetLegacyAccountService from "../account/getLegacyAccountService";
 import RbacsLocalStorage from "../local_storage/rbacLocalStorage";
-import UserMeSessionStorageService from "../sessionStorage/userMeSessionStorageService";
 import User from "../../model/user";
 import PasswordPoliciesLocalStorage from "../local_storage/passwordPoliciesLocalStorage";
 import PasswordExpirySettingsLocalStorage from "../local_storage/passwordExpirySettingsLocalStorage";
@@ -33,6 +31,9 @@ import MetadataKeysSettingsLocalStorage from "../local_storage/metadataKeysSetti
 import MetadataTypesSettingsLocalStorage from "../local_storage/metadataTypesSettingsLocalStorage";
 import MetadataKeysSessionStorage from "../session_storage/metadataKeysSessionStorage";
 import SessionKeysBundlesSessionStorageService from "../sessionStorage/sessionKeysBundlesSessionStorageService";
+import ActiveSessionLocalStorage from "../local_storage/activeSessionLocalStorage";
+import UserMeLocalStorage from "../local_storage/userMeLocalStorage";
+import SiteSettingsLocalStorage from "../local_storage/siteSettingsLocalStorage";
 
 /**
  * Flush storage data when:
@@ -45,9 +46,7 @@ class LocalStorageService {
    */
   static async flush() {
     ResourceLocalStorage.flush();
-    ResourceTypeLocalStorage.flush();
     FolderLocalStorage.flush();
-    AuthStatusLocalStorage.flush();
     UserLocalStorage.flush();
     RolesLocalStorage.flush();
     PasswordGeneratorLocalStorage.flush();
@@ -64,8 +63,10 @@ class LocalStorageService {
       return;
     }
 
-    const account = await GetLegacyAccountService.get();
+    const account = GetLegacyAccountService.get();
+    new ActiveSessionLocalStorage(account).flush();
     new RbacsLocalStorage(account).flush();
+    new ResourceTypeLocalStorage(account).flush();
     new PasswordPoliciesLocalStorage(account).flush();
     new PasswordExpirySettingsLocalStorage(account).flush();
     new MetadataKeysSettingsLocalStorage(account).flush();
@@ -73,7 +74,8 @@ class LocalStorageService {
     new MetadataKeysSessionStorage(account).flush();
     new SessionKeysBundlesSessionStorageService(account).flush();
     new GroupLocalStorage(account).flush();
-    UserMeSessionStorageService.remove(account);
+    new UserMeLocalStorage(account).flush();
+    new SiteSettingsLocalStorage(account).flush();
   }
 }
 

package/src/all/background_page/service/localStorage/localStorageService.test.js

@@ -14,10 +14,9 @@
 
 import LocalStorageService from "./localStorageService";
 import GetLegacyAccountService from "../account/getLegacyAccountService";
-import UserMeSessionStorageService from "../sessionStorage/userMeSessionStorageService";
 import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
 import AccountEntity from "../../model/entity/account/accountEntity";
-import { RBACS_LOCAL_STORAGE_KEY } from "../local_storage/rbacLocalStorage";
+import RbacLocalStorage, { RBACS_LOCAL_STORAGE_KEY } from "../local_storage/rbacLocalStorage";
 import MockExtension from "../../../../../test/mocks/mockExtension";
 import PostponeUserSettingInvitationService from "../invitation/postponeUserSettingInvitationService";
 import { PASSWORD_POLICIES_LOCAL_STORAGE_KEY } from "../local_storage/passwordPoliciesLocalStorage";
@@ -33,6 +32,12 @@ import SessionKeysBundlesSessionStorageService, {
 } from "../sessionStorage/sessionKeysBundlesSessionStorageService";
 import { METADATA_KEYS_SETTINGS_LOCAL_STORAGE_KEY } from "../local_storage/metadataKeysSettingsLocalStorage";
 import GroupLocalStorage, { GROUP_LOCAL_STORAGE_KEY } from "../local_storage/groupLocalStorage";
+import UserMeLocalStorage, { USER_ME_STORAGE_KEY_PREFIX } from "../local_storage/userMeLocalStorage";
+import ResourceTypeLocalStorage, { RESOURCE_TYPES_LOCAL_STORAGE_KEY } from "../local_storage/resourceTypeLocalStorage";
+import ActiveSessionLocalStorage, {
+  ACTIVE_SESSION_LOCAL_STORAGE_KEY,
+} from "../local_storage/activeSessionLocalStorage";
+import SiteSettingsLocalStorage, { SITE_SETTINGS } from "../local_storage/siteSettingsLocalStorage";
 
 beforeEach(() => {
   jest.clearAllMocks();
@@ -41,28 +46,30 @@ beforeEach(() => {
 describe("LocalStorageService", () => {
   describe("LocalStorageService::flush", () => {
     it("Should flush all storage (with no account set)", async () => {
-      expect.assertions(21);
+      expect.assertions(23);
       // spy on
       jest.spyOn(browser.storage.local, "remove");
       jest.spyOn(browser.storage.session, "remove");
       jest.spyOn(browser.alarms, "clear");
       jest.spyOn(GetLegacyAccountService, "get");
-      jest.spyOn(UserMeSessionStorageService, "remove");
+      jest.spyOn(UserMeLocalStorage.prototype, "flush");
       jest.spyOn(PostponeUserSettingInvitationService, "reset");
       jest.spyOn(MetadataTypesSettingsLocalStorage.prototype, "flush");
       jest.spyOn(MetadataKeysSessionStorage.prototype, "flush");
       jest.spyOn(SessionKeysBundlesSessionStorageService.prototype, "flush");
       jest.spyOn(GroupLocalStorage.prototype, "flush");
+      jest.spyOn(ResourceTypeLocalStorage.prototype, "flush");
+      jest.spyOn(RbacLocalStorage.prototype, "flush");
+      jest.spyOn(ActiveSessionLocalStorage.prototype, "flush");
+      jest.spyOn(SiteSettingsLocalStorage.prototype, "flush");
       // process
       await LocalStorageService.flush();
       // expectations
-      expect(browser.storage.local.remove).toHaveBeenCalledTimes(7);
+      expect(browser.storage.local.remove).toHaveBeenCalledTimes(5);
       expect(browser.storage.session.remove).toHaveBeenCalledTimes(2);
       expect(browser.alarms.clear).toHaveBeenCalledTimes(2);
       expect(browser.storage.local.remove).toHaveBeenCalledWith("resources");
-      expect(browser.storage.local.remove).toHaveBeenCalledWith("resourceTypes");
       expect(browser.storage.local.remove).toHaveBeenCalledWith("folders");
-      expect(browser.storage.local.remove).toHaveBeenCalledWith("auth_status");
       expect(browser.storage.local.remove).toHaveBeenCalledWith("users");
       expect(browser.storage.local.remove).toHaveBeenCalledWith("roles");
       expect(browser.storage.local.remove).toHaveBeenCalledWith("passwordGenerator");
@@ -72,15 +79,19 @@ describe("LocalStorageService", () => {
       expect(browser.alarms.clear).toHaveBeenCalledWith("SessionKeepAlive");
       expect(browser.storage.session.remove).toHaveBeenCalledWith("temp_server_part_sso_kit");
       expect(GetLegacyAccountService.get).not.toHaveBeenCalled();
-      expect(UserMeSessionStorageService.remove).not.toHaveBeenCalled();
+      expect(UserMeLocalStorage.prototype.flush).not.toHaveBeenCalled();
       expect(MetadataTypesSettingsLocalStorage.prototype.flush).not.toHaveBeenCalled();
       expect(MetadataKeysSessionStorage.prototype.flush).not.toHaveBeenCalled();
       expect(SessionKeysBundlesSessionStorageService.prototype.flush).not.toHaveBeenCalled();
       expect(GroupLocalStorage.prototype.flush).not.toHaveBeenCalled();
+      expect(ResourceTypeLocalStorage.prototype.flush).not.toHaveBeenCalled();
+      expect(RbacLocalStorage.prototype.flush).not.toHaveBeenCalled();
+      expect(ActiveSessionLocalStorage.prototype.flush).not.toHaveBeenCalled();
+      expect(SiteSettingsLocalStorage.prototype.flush).not.toHaveBeenCalled();
     });
 
     it("Should flush all storage (with an account set)", async () => {
-      expect.assertions(26);
+      expect.assertions(30);
       // mock data
       MockExtension.withConfiguredAccount();
       const account = new AccountEntity(defaultAccountDto());
@@ -90,17 +101,16 @@ describe("LocalStorageService", () => {
       jest.spyOn(browser.alarms, "clear");
       jest.spyOn(PostponeUserSettingInvitationService, "reset");
       jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
-      jest.spyOn(UserMeSessionStorageService, "remove");
       // process
       await LocalStorageService.flush();
+      // Need to wait metadata and data to be removed
+      await Promise.resolve();
       // expectations
-      expect(browser.storage.local.remove).toHaveBeenCalledTimes(13);
-      expect(browser.storage.session.remove).toHaveBeenCalledTimes(5);
+      expect(browser.storage.local.remove).toHaveBeenCalledTimes(19);
+      expect(browser.storage.session.remove).toHaveBeenCalledTimes(4);
       expect(browser.alarms.clear).toHaveBeenCalledTimes(2);
       expect(browser.storage.local.remove).toHaveBeenCalledWith("resources");
-      expect(browser.storage.local.remove).toHaveBeenCalledWith("resourceTypes");
       expect(browser.storage.local.remove).toHaveBeenCalledWith("folders");
-      expect(browser.storage.local.remove).toHaveBeenCalledWith("auth_status");
       expect(browser.storage.local.remove).toHaveBeenCalledWith("users");
       expect(browser.storage.local.remove).toHaveBeenCalledWith("groups");
       expect(browser.storage.local.remove).toHaveBeenCalledWith("roles");
@@ -111,6 +121,7 @@ describe("LocalStorageService", () => {
       expect(browser.alarms.clear).toHaveBeenCalledWith("SessionKeepAlive");
       expect(browser.storage.session.remove).toHaveBeenCalledWith("temp_server_part_sso_kit");
       expect(GetLegacyAccountService.get).toHaveBeenCalled();
+      expect(browser.storage.local.remove).toHaveBeenCalledWith(`${RBACS_LOCAL_STORAGE_KEY}-metadata-${account.id}`);
       expect(browser.storage.local.remove).toHaveBeenCalledWith(`${RBACS_LOCAL_STORAGE_KEY}-${account.id}`);
       expect(browser.storage.local.remove).toHaveBeenCalledWith(`${PASSWORD_POLICIES_LOCAL_STORAGE_KEY}-${account.id}`);
       expect(browser.storage.local.remove).toHaveBeenCalledWith(
@@ -126,8 +137,15 @@ describe("LocalStorageService", () => {
       expect(browser.storage.session.remove).toHaveBeenCalledWith(
         `${SESSION_KEYS_BUNDLES_SESSION_STORAGE_KEY}-${account.id}`,
       );
-      expect(UserMeSessionStorageService.remove).toHaveBeenCalledWith(account);
+      expect(browser.storage.local.remove).toHaveBeenCalledWith(`${USER_ME_STORAGE_KEY_PREFIX}-metadata-${account.id}`);
+      expect(browser.storage.local.remove).toHaveBeenCalledWith(`${USER_ME_STORAGE_KEY_PREFIX}-${account.id}`);
       expect(browser.storage.local.remove).toHaveBeenCalledWith(`${GROUP_LOCAL_STORAGE_KEY}`);
+      expect(browser.storage.local.remove).toHaveBeenCalledWith(
+        `${RESOURCE_TYPES_LOCAL_STORAGE_KEY}-metadata-${account.id}`,
+      );
+      expect(browser.storage.local.remove).toHaveBeenCalledWith(`${RESOURCE_TYPES_LOCAL_STORAGE_KEY}-${account.id}`);
+      expect(browser.storage.local.remove).toHaveBeenCalledWith(`${ACTIVE_SESSION_LOCAL_STORAGE_KEY}-${account.id}`);
+      expect(browser.storage.local.remove).toHaveBeenCalledWith(`${SITE_SETTINGS}-${account.id}`);
       /**
        * TODO: Re-enable this test assertion once local storage flush operations are properly awaited.
        * Currently disabled because the storage flush for the second key may not complete

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

@@ -0,0 +1,193 @@
+/**
+ * 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         6.0.0
+ */
+import Log from "../../model/log";
+import { assertType } from "../../utils/assertions";
+import LocalStorageMetadataEntity from "../../model/entity/localStorage/localStorageMetadataEntity";
+import AbstractAccountEntity from "../../model/entity/account/abstractAccountEntity";
+
+class AbstractLocalStorage {
+  /**
+   * Runtime cached data.
+   * @type {Object} Key: account_id, value: cached data as dto.
+   * @private
+   */
+  static _runtimeCachedData = {};
+
+  /**
+   * Runtime cached metadata.
+   * @type {Object} Key: account_id, value: cached metadata as dto.
+   * @private
+   */
+  static _runtimeCachedMetadata = {};
+
+  /**
+   * Constructor
+   * @param account the user account
+   */
+  constructor(account) {
+    if (!account || !(account instanceof AbstractAccountEntity)) {
+      throw new TypeError("Parameter `account` should be of type AbstractAccountEntity.");
+    }
+    this.account = account;
+    this.storageMetadataKey = this.getMetadataStorageKey(account);
+    this.storageDataKey = this.getDataStorageKey(account);
+  }
+
+  /**
+   * Get the metadata data storage key.
+   * @param {AbstractAccountEntity} account The account to get the key for.
+   * @returns {string}
+   * @throws {Error} If it cannot retrieve account id.
+   */
+  getMetadataStorageKey(account) {
+    return `${this.key}-metadata-${account.id}`;
+  }
+
+  /**
+   * Get the data storage key.
+   * @param {AbstractAccountEntity} account The account to get the key for.
+   * @returns {string}
+   * @throws {Error} If it cannot retrieve account id.
+   */
+  getDataStorageKey(account) {
+    return `${this.key}-${account.id}`;
+  }
+
+  /**
+   * Flush the active session from local storage and runtime cached data.
+   * @return {Promise<void>}
+   */
+  async flush() {
+    await browser.storage.local.remove(this.storageMetadataKey);
+    await browser.storage.local.remove(this.storageDataKey);
+    delete AbstractLocalStorage._runtimeCachedData[this.storageDataKey];
+    delete AbstractLocalStorage._runtimeCachedMetadata[this.storageMetadataKey];
+    Log.write({ level: "debug", message: `${this.key} metadata flushed for (${this.account.id})` });
+    Log.write({ level: "debug", message: `${this.key} flushed for (${this.account.id})` });
+  }
+
+  /**
+   * Get the metadata from the local storage.
+   * @return {Promise<object|undefined>}
+   */
+  async getMetadata() {
+    if (!AbstractLocalStorage._runtimeCachedMetadata[this.storageMetadataKey]) {
+      const data = await browser.storage.local.get([this.storageMetadataKey]);
+      if (!data[this.storageMetadataKey]) {
+        return;
+      }
+      AbstractLocalStorage._runtimeCachedMetadata[this.storageMetadataKey] = data[this.storageMetadataKey];
+    }
+
+    return AbstractLocalStorage._runtimeCachedMetadata[this.storageMetadataKey];
+  }
+
+  /**
+   * Get the data from the local storage.
+   * @return {Promise<object|Array|undefined>}
+   */
+  async getData() {
+    if (!AbstractLocalStorage._runtimeCachedData[this.storageDataKey]) {
+      const data = await browser.storage.local.get([this.storageDataKey]);
+      if (!data[this.storageDataKey]) {
+        return;
+      }
+      AbstractLocalStorage._runtimeCachedData[this.storageDataKey] = data[this.storageDataKey];
+    }
+
+    return AbstractLocalStorage._runtimeCachedData[this.storageDataKey];
+  }
+
+  /**
+   * Set the data in the local storage and update the metadata.
+   * @param {EntityV2|EntityV2Collection} data The data to insert in the local storage.
+   * @return {Promise<void>}
+   * @throws {TypeError} If parameter settings is not of type entityClass.
+   */
+  async setData(data) {
+    assertType(data, this.entityClass, `Parameter "data" should be of type ${this.entityClass.constructor.name}`);
+    await navigator.locks.request(this.storageDataKey, async () => {
+      const dataDto = data.toDto(this.constructor.DEFAULT_CONTAIN);
+      await this._setBrowserStorage({ [this.storageDataKey]: dataDto });
+      AbstractLocalStorage._runtimeCachedData[this.storageDataKey] = dataDto;
+    });
+    const date = new Date().toISOString();
+    const metadata = new LocalStorageMetadataEntity({ last_updated: date });
+    await this.setMetadata(metadata);
+  }
+
+  /**
+   * Set the data in the local storage and update the metadata.
+   * @param {LocalStorageMetadataEntity} metadata The data to insert in the local storage.
+   * @return {Promise<void>}
+   * @throws {TypeError} If parameter settings is not of type entityClass.
+   */
+  async setMetadata(metadata) {
+    assertType(
+      metadata,
+      LocalStorageMetadataEntity,
+      "Parameter 'metadata' should be of type LocalStorageMetadataEntity",
+    );
+    await navigator.locks.request(this.storageMetadataKey, async () => {
+      const metadataDto = metadata.toDto(this.constructor.DEFAULT_CONTAIN);
+      await this._setBrowserStorage({ [this.storageMetadataKey]: metadataDto });
+      AbstractLocalStorage._runtimeCachedMetadata[this.storageMetadataKey] = metadataDto;
+    });
+  }
+
+  /**
+   * Set the browser storage.
+   * @param {object} data The data to store in the local storage.
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _setBrowserStorage(data) {
+    await browser.storage.local.set(data);
+  }
+
+  /**
+   * Get the key name
+   * @returns {string}
+   */
+  get key() {
+    Log.write({
+      level: "debug",
+      message: "The local storage should implement key. Default throw an error.",
+    });
+    throw new Error("The local storage should implement key.");
+  }
+
+  /**
+   * Get the entity class
+   * @returns {Class}
+   */
+  get entityClass() {
+    Log.write({
+      level: "debug",
+      message: "The local storage should implement entityClass. Default throw an error.",
+    });
+    throw new Error("The local storage should implement entityClass.");
+  }
+
+  /**
+   * Get the contain options
+   * @return {{}}
+   * @constructor
+   */
+  static get DEFAULT_CONTAIN() {
+    return {};
+  }
+}
+
+export default AbstractLocalStorage;

package/src/all/background_page/service/local_storage/abstractLocalStorage.test.data.js

@@ -0,0 +1,45 @@
+/**
+ * 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         6.0.0
+ */
+import AbstractLocalStorage from "./abstractLocalStorage";
+import EntityV2 from "passbolt-styleguide/src/shared/models/entity/abstract/entityV2";
+
+export class TestLocalStorage extends AbstractLocalStorage {
+  get key() {
+    return "test_local_storage";
+  }
+
+  get entityClass() {
+    return TestEntityLocalStorage;
+  }
+}
+
+export class TestEntityLocalStorage extends EntityV2 {
+  static getSchema() {
+    return {
+      type: "object",
+      required: ["name"],
+      properties: {
+        id: {
+          type: "string",
+          format: "uuid",
+          nullable: true,
+        },
+        name: {
+          type: "string",
+          nullable: true,
+        },
+      },
+    };
+  }
+}