passbolt-browser-extension 5.13.0 → 5.14.2

package/src/all/background_page/service/resource/findResourcesService.test.js

@@ -38,6 +38,7 @@ import { defaultDecryptedSharedMetadataKeysDtos } from "passbolt-styleguide/src/
 import PassphraseStorageService from "../session_storage/passphraseStorageService";
 import { OpenpgpAssertion } from "../../utils/openpgp/openpgpAssertions";
 import { mockPassboltResponse } from "passbolt-styleguide/test/mocks/mockApiResponse";
+import DecryptMetadataService from "../metadata/decryptMetadataService";
 
 beforeEach(() => {
   jest.clearAllMocks();
@@ -492,42 +493,43 @@ describe("FindResourcesService", () => {
     });
   });
 
-  describe("::findAllByIdsForDisplayPermissions", () => {
+  describe("::findAllPermissionsByIdsForShare", () => {
     let service, expectedContains;
 
     beforeEach(() => {
       service = new FindResourcesService(account, apiClientOptions);
       expectedContains = {
-        permission: true,
         "permissions.user.profile": true,
         "permissions.group": true,
       };
     });
 
-    it("should call the api only 1 times when the resource is less than 80", async () => {
-      expect.assertions(3);
+    it("should request the permissions without the metadata and without decrypting it", async () => {
+      expect.assertions(4);
 
       const collectionDto = Array.from({ length: 80 }, () => defaultResourceDto());
       const collectionIds = collectionDto.map((collection) => collection.id);
 
       jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => mockPassboltResponse(collectionDto));
+      jest.spyOn(DecryptMetadataService.prototype, "decryptAllFromForeignModels");
 
-      const result = await service.findAllByIdsForDisplayPermissions(collectionIds);
+      const result = await service.findAllPermissionsByIdsForShare(collectionIds);
 
       expect(result).toEqual(new ResourcesCollection(collectionDto));
-      expect(ResourceService.prototype.findAll).toHaveBeenCalledTimes(1);
       expect(ResourceService.prototype.findAll).toHaveBeenCalledWith(expectedContains, {
         "has-id": collectionIds,
       });
+      expect(ResourceService.prototype.findAll).toHaveBeenCalledTimes(1);
+      // No metadata is requested, so the operator is never prompted for a passphrase to decrypt it.
+      expect(DecryptMetadataService.prototype.decryptAllFromForeignModels).not.toHaveBeenCalled();
     });
 
-    it("should call the api only 2 times when the resource is more than 80", async () => {
-      expect.assertions(4);
+    it("should chunk the ids by 80 to avoid a too long url", async () => {
+      expect.assertions(3);
 
       const collectionDto = Array.from({ length: 82 }, () => defaultResourceDto());
       const resultCollectionDto = [...collectionDto];
       const collectionIds = collectionDto.map((collection) => collection.id);
-      jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => mockPassboltResponse(collectionDto));
 
       jest.spyOn(ResourceService.prototype, "findAll").mockImplementation((contains, filters) => {
         expect(contains).toEqual(expectedContains);
@@ -535,9 +537,8 @@ describe("FindResourcesService", () => {
         return mockPassboltResponse(splicedCollection);
       });
 
-      const result = await service.findAllByIdsForDisplayPermissions(collectionIds);
+      await service.findAllPermissionsByIdsForShare(collectionIds);
 
-      expect(result.toDto()).toEqual(collectionDto);
       expect(ResourceService.prototype.findAll).toHaveBeenCalledTimes(2);
     });
   });

package/src/all/background_page/service/resource/getOrFindResourcesService.js

@@ -14,8 +14,8 @@
 import ResourceLocalStorage from "../local_storage/resourceLocalStorage";
 import ResourcesCollection from "../../model/entity/resource/resourcesCollection";
 import FindAndUpdateResourcesLocalStorage from "./findAndUpdateResourcesLocalStorageService";
-import ResourceTypeModel from "../../model/resourceType/resourceTypeModel";
 import { assertArrayUUID } from "../../utils/assertions";
+import GetOrFindResourceTypesService from "../resourceType/getOrFindResourceTypesService";
 
 /**
  * The service aims to get resources from the local storage if it is set, or retrieve them from the API and
@@ -29,7 +29,7 @@ export default class GetOrFindResourcesService {
    */
   constructor(account, apiClientOptions) {
     this.account = account;
-    this.resourceTypeModel = new ResourceTypeModel(apiClientOptions);
+    this.getOrFindResourceTypesService = new GetOrFindResourceTypesService(account, apiClientOptions);
     this.findAndUpdateResourcesLocalStorage = new FindAndUpdateResourcesLocalStorage(account, apiClientOptions);
   }
 
@@ -65,7 +65,7 @@ export default class GetOrFindResourcesService {
     }
 
     const resourcesCollection = await this.getOrFindAll();
-    const resourceTypesCollection = await this.resourceTypeModel.getOrFindAll();
+    const resourceTypesCollection = await this.getOrFindResourceTypesService.getOrFindAll();
 
     // Filter resource types according to what we need
     if (fieldType === "otp") {

package/src/all/background_page/service/resource/import/ImportResourcesService.js

@@ -22,7 +22,6 @@ import FolderModel from "../../../model/folder/folderModel";
 import ResourcesImportParser from "../../../model/import/resourcesImportParser";
 import Keyring from "../../../model/keyring";
 import ResourceModel from "../../../model/resource/resourceModel";
-import ResourceTypeModel from "../../../model/resourceType/resourceTypeModel";
 import { OpenpgpAssertion } from "../../../utils/openpgp/openpgpAssertions";
 import ResourceService from "../../api/resource/resourceService";
 import EncryptMessageService from "../../crypto/encryptMessageService";
@@ -36,8 +35,9 @@ import DecryptPrivateKeyService from "../../crypto/decryptPrivateKeyService";
 import DecryptMetadataService from "../../metadata/decryptMetadataService";
 import ResourceMetadataEntity from "passbolt-styleguide/src/shared/models/entity/resource/metadata/resourceMetadataEntity";
 import PasswordExpirySettingsGetOrFindService from "../../passwordExpirySettings/passwordExpirySettingsGetOrFindService";
-import OrganizationSettingsModel from "../../../model/organizationSettings/organizationSettingsModel";
+import GetOrFindSiteSettingsService from "../../siteSettings/getOrFindSiteSettingsService";
 import UpdateResourceTagsService from "../../tag/updateResourceTagsService";
+import GetOrFindResourceTypesService from "../../resourceType/getOrFindResourceTypesService";
 
 /**
  * The service aim to import the resources from a file and save it to the API / localstorage.
@@ -54,7 +54,6 @@ class ImportResourcesService {
     //Models
     this.resourceModel = new ResourceModel(apiClientOptions, account);
     this.folderModel = new FolderModel(apiClientOptions, account);
-    this.resourceTypeModel = new ResourceTypeModel(apiClientOptions);
     //Services
     this.resourceService = new ResourceService(apiClientOptions);
     this.executeConcurrentlyService = new ExecuteConcurrentlyService();
@@ -63,8 +62,9 @@ class ImportResourcesService {
     this.getOrFindMetadataSettingsService = new GetOrFindMetadataSettingsService(account, apiClientOptions);
     this.encryptMetadataService = new EncryptMetadataService(apiClientOptions, account);
     this.decryptMetadataService = new DecryptMetadataService(apiClientOptions, account);
-    this.organisationSettingsModel = new OrganizationSettingsModel(apiClientOptions);
+    this.getOrFindSiteSettingsService = new GetOrFindSiteSettingsService(account, apiClientOptions);
     this.passwordExpirySettingsGetOrFindService = new PasswordExpirySettingsGetOrFindService(account, apiClientOptions);
+    this.getOrFindResourceTypesService = new GetOrFindResourceTypesService(account, apiClientOptions);
     this.account = account;
   }
 
@@ -76,7 +76,7 @@ class ImportResourcesService {
    */
   async importFile(importResourcesFile, passphrase) {
     const userId = User.getInstance().get().id;
-    const organizationSettings = await this.organisationSettingsModel.getOrFind();
+    const organizationSettings = await this.getOrFindSiteSettingsService.getOrFind(false);
     const privateKey = await DecryptPrivateKeyService.decryptArmoredKey(this.account.userPrivateArmoredKey, passphrase);
     await this.encryptSecrets(importResourcesFile, userId, privateKey);
     importResourcesFile.mustImportFolders && (await this.bulkImportFolders(importResourcesFile));
@@ -102,7 +102,7 @@ class ImportResourcesService {
   async parseFile(importResourcesFile) {
     const metadataTypesSettings = await this.getOrFindMetadataSettingsService.getOrFindTypesSettings();
     const importParser = new ResourcesImportParser();
-    const resourceTypesCollection = await this.resourceTypeModel.getOrFindAll();
+    const resourceTypesCollection = await this.getOrFindResourceTypesService.getOrFindAll();
     await importParser.parseImport(importResourcesFile, resourceTypesCollection, metadataTypesSettings);
 
     // Now that we know about the content of the import, update the progress bar goals.
@@ -133,7 +133,7 @@ class ImportResourcesService {
     if (passwordExpirySettings?.isFeatureEnabled) {
       const passwordExpiryDate = passwordExpirySettings.calculateDefaultResourceExpiryDate();
       if (passwordExpiryDate) {
-        const resourceTypesCollection = await this.resourceTypeModel.getOrFindAll();
+        const resourceTypesCollection = await this.getOrFindResourceTypesService.getOrFindAll();
         resourcesCollection.setExpiryDateIfUnset(passwordExpiryDate, resourceTypesCollection);
       }
     }
@@ -165,7 +165,7 @@ class ImportResourcesService {
     let i = 0;
     const userPublicArmoredKey = this.keyring.findPublic(userId).armoredKey;
     const userPublicKey = await OpenpgpAssertion.readKeyOrFail(userPublicArmoredKey);
-    const resourceTypes = await this.resourceTypeModel.getOrFindAll();
+    const resourceTypes = await this.getOrFindResourceTypesService.getOrFindAll();
     for (const importResourceEntity of importResourcesFile.importResources) {
       i++;
       await this.progressService.finishStep(
@@ -353,7 +353,7 @@ class ImportResourcesService {
    */
   async bulkImportResources(importResourcesFile, resourcesCollection, clearTextMetadataResourcesCollection) {
     let importedCount = 0;
-    const resourceTypesCollection = await this.resourceTypeModel.getOrFindAll();
+    const resourceTypesCollection = await this.getOrFindResourceTypesService.getOrFindAll();
 
     const callbacks = resourcesCollection.items.map((resourceEntity, index) => async () => {
       try {

package/src/all/background_page/service/resource/import/ImportResourcesService.test.js

@@ -72,11 +72,15 @@ import DecryptMetadataService from "../../metadata/decryptMetadataService";
 import { defaultPasswordExpirySettingsDtoFromApi } from "passbolt-styleguide/src/shared/models/entity/passwordExpiry/passwordExpirySettingsEntity.test.data";
 import PasswordExpirySettingsService from "../../api/passwordExpiry/passwordExpirySettingsService";
 import {
-  defaultCeOrganizationSettings,
-  defaultProOrganizationSettings,
-} from "../../../model/entity/organizationSettings/organizationSettingsEntity.test.data";
-import OrganizationSettingsService from "../../api/organizationSettings/organizationSettingsService";
+  anonymousSiteSettings,
+  defaultCeSiteSettings,
+  defaultProSiteSettings,
+} from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity.test.data";
+import GetOrFindSiteSettingsService from "../../siteSettings/getOrFindSiteSettingsService";
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
 import PassboltResponseEntity from "passbolt-styleguide/src/shared/models/entity/apiService/PassboltResponseEntity";
+import GetOrFindResourceTypesService from "../../resourceType/getOrFindResourceTypesService";
+import ResourceTypesCollection from "passbolt-styleguide/src/shared/models/entity/resourceType/resourceTypesCollection";
 
 jest.mock("../../../service/progress/progressService");
 
@@ -119,6 +123,9 @@ describe("ImportResourcesService", () => {
     };
     decryptMetadataService = new DecryptMetadataService(apiClientOptions, account);
     importResourcesService = new ImportResourcesService(account, apiClientOptions, new ProgressService(worker, ""));
+    jest
+      .spyOn(GetOrFindSiteSettingsService.prototype, "getOrFind")
+      .mockImplementation(() => new SiteSettingsEntity(anonymousSiteSettings()));
     collection = resourceTypesCollectionDto();
     jest.spyOn(ResourceTypeService.prototype, "findAll").mockImplementation(() => collection);
     importResourceFileCSV = new ImportResourcesFileEntity(defaultImportResourceFileCSVDto());
@@ -402,7 +409,9 @@ describe("ImportResourcesService", () => {
       it("Should throw an error if the resource type cannot be found", async () => {
         expect.assertions(5);
 
-        jest.spyOn(ResourceTypeService.prototype, "findAll").mockImplementation(() => []);
+        jest
+          .spyOn(GetOrFindResourceTypesService.prototype, "getOrFindAll")
+          .mockImplementationOnce(() => new ResourceTypesCollection([]));
 
         importResourceFileCSV = new ImportResourcesFileEntity(
           defaultImportResourceFileCSVDto({
@@ -711,8 +720,8 @@ describe("ImportResourcesService", () => {
           expect.assertions(3);
 
           jest
-            .spyOn(OrganizationSettingsService.prototype, "find")
-            .mockImplementation(() => defaultProOrganizationSettings());
+            .spyOn(GetOrFindSiteSettingsService.prototype, "getOrFind")
+            .mockImplementation(() => new SiteSettingsEntity(defaultProSiteSettings()));
 
           jest.spyOn(PasswordExpirySettingsService.prototype, "find").mockImplementation(() =>
             defaultPasswordExpirySettingsDtoFromApi({
@@ -737,10 +746,12 @@ describe("ImportResourcesService", () => {
           it("password expiry plugin is disabled", async () => {
             expect.assertions(3);
 
-            const organizationSettings = defaultProOrganizationSettings();
+            const organizationSettings = defaultProSiteSettings();
             organizationSettings.passbolt.plugins.passwordExpiry.enabled = false;
 
-            jest.spyOn(OrganizationSettingsService.prototype, "find").mockImplementation(() => organizationSettings);
+            jest
+              .spyOn(GetOrFindSiteSettingsService.prototype, "getOrFind")
+              .mockImplementation(() => new SiteSettingsEntity(organizationSettings));
 
             jest.spyOn(PasswordExpirySettingsService.prototype, "find").mockImplementation(() =>
               defaultPasswordExpirySettingsDtoFromApi({
@@ -764,10 +775,12 @@ describe("ImportResourcesService", () => {
           it("password expiry policies feature is disabled", async () => {
             expect.assertions(3);
 
-            const organizationSettings = defaultProOrganizationSettings();
+            const organizationSettings = defaultProSiteSettings();
             organizationSettings.passbolt.plugins.passwordExpiryPolicies.enabled = false;
 
-            jest.spyOn(OrganizationSettingsService.prototype, "find").mockImplementation(() => organizationSettings);
+            jest
+              .spyOn(GetOrFindSiteSettingsService.prototype, "getOrFind")
+              .mockImplementation(() => new SiteSettingsEntity(organizationSettings));
 
             jest.spyOn(PasswordExpirySettingsService.prototype, "find").mockImplementation(() =>
               defaultPasswordExpirySettingsDtoFromApi({
@@ -792,8 +805,8 @@ describe("ImportResourcesService", () => {
             expect.assertions(3);
 
             jest
-              .spyOn(OrganizationSettingsService.prototype, "find")
-              .mockImplementation(() => defaultProOrganizationSettings());
+              .spyOn(GetOrFindSiteSettingsService.prototype, "getOrFind")
+              .mockImplementation(() => new SiteSettingsEntity(defaultProSiteSettings()));
 
             jest
               .spyOn(PasswordExpirySettingsService.prototype, "find")
@@ -824,13 +837,15 @@ describe("ImportResourcesService", () => {
         it("Should not set expiry date even when password expiry plugin is enabled", async () => {
           expect.assertions(3);
 
-          const organizationSettings = defaultCeOrganizationSettings();
+          const organizationSettings = defaultCeSiteSettings();
           organizationSettings.passbolt.plugins.passwordExpiry = {
             version: "1.0.0",
             enabled: true,
           };
 
-          jest.spyOn(OrganizationSettingsService.prototype, "find").mockImplementation(() => organizationSettings);
+          jest
+            .spyOn(GetOrFindSiteSettingsService.prototype, "getOrFind")
+            .mockImplementation(() => new SiteSettingsEntity(organizationSettings));
 
           jest
             .spyOn(PasswordExpirySettingsService.prototype, "find")

package/src/all/background_page/service/resource/update/resourceUpdateService.js

@@ -24,8 +24,10 @@ import { OpenpgpAssertion } from "../../../utils/openpgp/openpgpAssertions";
 import EncryptMessageService from "../../crypto/encryptMessageService";
 import ResourceSecretsCollection from "../../../model/entity/secret/resource/resourceSecretsCollection";
 import EncryptMetadataKeysService from "../../metadata/encryptMetadataService";
-import ResourceTypeModel from "../../../model/resourceType/resourceTypeModel";
 import FindPermissionsService from "../../permission/findPermissionsService";
+import GetOrFindResourceTypesService from "../../resourceType/getOrFindResourceTypesService";
+import PermissionChangesCollection from "../../../model/entity/permission/change/permissionChangesCollection";
+import ShareResourceService, { PROGRESS_STEPS_SHARE_RESOURCES_SHARE_ALL } from "../../share/shareResourceService";
 
 class ResourceUpdateService {
   /**
@@ -37,13 +39,14 @@ class ResourceUpdateService {
   constructor(account, apiClientOptions, progressService) {
     this.account = account;
     this.resourceService = new ResourceService(apiClientOptions);
-    this.resourceTypeModel = new ResourceTypeModel(apiClientOptions);
+    this.getOrFindResourcetypesService = new GetOrFindResourceTypesService(account, apiClientOptions);
     this.progressService = progressService;
     this.findPermissionsService = new FindPermissionsService(account, apiClientOptions);
-    this.resourceModel = new ResourceModel(apiClientOptions);
+    this.resourceModel = new ResourceModel(apiClientOptions, account);
     this.encryptMetadataKeysService = new EncryptMetadataKeysService(apiClientOptions, this.account);
     this.userModel = new UserModel(apiClientOptions);
     this.keyring = new Keyring();
+    this.shareResourceService = new ShareResourceService(apiClientOptions, account, progressService);
   }
 
   /**
@@ -52,21 +55,37 @@ class ResourceUpdateService {
    * @param {object} resourceDto The resource data
    * @param {string|object|null} plaintextDto The secret to encrypt, or null to keep the existing secret
    * @param {string} passphrase The user passphrase
+   * @param {Array<object>} [permissionChanges] Optional permission changes applied after the update.
    * @return {Promise<ResourceEntity>} resourceEntity
    */
-  async exec(resourceDto, plaintextDto, passphrase) {
+  async exec(resourceDto, plaintextDto, passphrase, permissionChanges) {
     const resourceEntity = new ResourceEntity(resourceDto);
-    const resourceTypesCollection = await this.resourceTypeModel.getOrFindAll();
+
+    permissionChanges = permissionChanges ?? [];
+    // Apply the operator-confirmed permission changes (re-share) in the spec-mandated safe order.
+    if (permissionChanges.length > 0) {
+      // The styleguide emits deltas with aco_foreign_key unset (or null); stamp the resource id
+      // before handing them to the share orchestration.
+      const stampedChanges = permissionChanges.map((change) => ({
+        ...change,
+        aco_foreign_key: resourceEntity.id,
+      }));
+      await this.shareResourceService.shareAll(
+        [resourceEntity.id],
+        new PermissionChangesCollection(stampedChanges),
+        passphrase,
+      );
+    }
+
+    const resourceTypesCollection = await this.getOrFindResourcetypesService.getOrFindAll();
     const resourceTypeEntity = resourceTypesCollection.getFirstById(resourceEntity.resourceTypeId);
-    const permissionsCollection = await this.findPermissionsService.findAllByAcoForeignKey(resourceEntity.id);
 
     // Get users ids of those who have access to the resource
     const usersIds = await this.userModel.findAllIdsForResourceUpdate(resourceEntity.id);
-    // Set personal property only if resource is not shared with user and group
-    resourceEntity.personal = usersIds.length === 1 && !permissionsCollection.hasGroupPermission;
     // Set goals
-    const goals = this.calculateGoals(plaintextDto, resourceTypeEntity, usersIds.length);
+    const goals = this.calculateGoals(plaintextDto, resourceTypeEntity, usersIds.length, permissionChanges.length);
     this.progressService.updateGoals(goals);
+
     // Keep metadata decrypted to update it in the local storage
     const metadataDecrypted = resourceEntity.metadata;
     if (resourceTypeEntity.isV5()) {
@@ -74,12 +93,14 @@ class ResourceUpdateService {
       await this.progressService.finishStep(i18n.t("Encrypting Metadata"), true);
       await this.encryptMetadataKeysService.encryptOneForForeignModel(resourceEntity, passphrase);
     }
+
     if (plaintextDto !== null) {
       // Update secret
       await this.updateSecret(resourceEntity, plaintextDto, passphrase, usersIds);
     }
+
     // Update resource
-    return this.update(resourceEntity, resourceTypeEntity, metadataDecrypted);
+    return await this.update(resourceEntity, resourceTypeEntity, metadataDecrypted);
   }
 
   /**
@@ -95,10 +116,6 @@ class ResourceUpdateService {
     // Get the passphrase if needed and decrypt secret key
     const privateKey = await DecryptPrivateKeyService.decryptArmoredKey(this.account.userPrivateArmoredKey, passphrase);
 
-    // Sync keyring
-    await this.progressService.finishStep(i18n.t("Synchronizing keyring"), true);
-    await this.keyring.sync();
-
     // Encrypt
     const plaintext = await this.resourceModel.serializePlaintextDto(resourceEntity.resourceTypeId, plaintextDto);
     resourceEntity.secrets = await this.encryptSecrets(plaintext, usersIds, privateKey);
@@ -162,15 +179,17 @@ class ResourceUpdateService {
    * @param {string|object} plaintextDto The secret to encrypt
    * @param {ResourceTypeEntity} resourceType The resource type
    * @param {number} usersLength The number of users
+   * @param {number} [permissionChangesLength] The number of permission changes applied after the update
    * @returns {number}
    */
-  calculateGoals(plaintextDto, resourceType, usersLength) {
+  calculateGoals(plaintextDto, resourceType, usersLength, permissionChangesLength = 0) {
+    const shareSteps = permissionChangesLength > 0 ? PROGRESS_STEPS_SHARE_RESOURCES_SHARE_ALL : 0;
     if (resourceType.isV5()) {
-      // encrypt metadata + save + done or encrypt secret * users + encrypt metadata + keyring sync + save + done
-      return plaintextDto === null ? 3 : usersLength + 4;
+      // encrypt metadata + save + done or encrypt secret * users + encrypt metadata + save + done
+      return (plaintextDto === null ? 3 : usersLength + 3) + shareSteps;
     } else if (resourceType.isV4()) {
-      // save + done or encrypt secret * users + keyring sync + save + done
-      return plaintextDto === null ? 2 : usersLength + 3;
+      // save + done or encrypt secret * users + save + done
+      return (plaintextDto === null ? 2 : usersLength + 2) + shareSteps;
     }
   }
 }

package/src/all/background_page/service/resource/update/resourceUpdateService.test.js

@@ -116,7 +116,7 @@ describe("ResourceUpdateService", () => {
 
   describe("ResourceUpdateService::exec", () => {
     it("Should call progress service during the different steps of creation", async () => {
-      expect.assertions(8);
+      expect.assertions(7);
 
       const resourceDto = defaultResourceDto();
       const entity = new ResourceEntity(resourceDto);
@@ -140,9 +140,8 @@ describe("ResourceUpdateService", () => {
       );
 
       expect(resourceUpdateService.progressService.updateGoals).toHaveBeenCalledTimes(1);
-      expect(resourceUpdateService.progressService.updateGoals).toHaveBeenCalledWith(6);
-      expect(resourceUpdateService.progressService.finishStep).toHaveBeenCalledTimes(5);
-      expect(resourceUpdateService.progressService.finishStep).toHaveBeenCalledWith("Synchronizing keyring", true);
+      expect(resourceUpdateService.progressService.updateGoals).toHaveBeenCalledWith(5);
+      expect(resourceUpdateService.progressService.finishStep).toHaveBeenCalledTimes(4);
       expect(resourceUpdateService.progressService.finishStep).toHaveBeenCalledWith("Encrypting Secret", true);
       expect(resourceUpdateService.progressService.finishStep).toHaveBeenCalledWith("Saving resource", true);
       expect(ResourceLocalStorage.updateResource).toHaveBeenCalledTimes(1);
@@ -151,6 +150,67 @@ describe("ResourceUpdateService", () => {
       );
     });
 
+    it("Should apply the permission changes via shareAll after the update, stamping the resource id", async () => {
+      expect.assertions(3);
+
+      const resourceDto = defaultResourceDto();
+      await ResourceLocalStorage.addResource(new ResourceEntity(resourceDto));
+      jest
+        .spyOn(resourceUpdateService.resourceService, "update")
+        .mockImplementation((resourceIdToUpdate, resourceDtoToUpdate) => {
+          const resourceEntity = new ResourceEntity(resourceDto);
+          resourceEntity.secrets = new ResourceSecretsCollection([resourceDtoToUpdate.secrets[0]]);
+          return resourceEntity.toV4Dto(ResourceLocalStorage.DEFAULT_CONTAIN);
+        });
+      const shareAllSpy = jest
+        .spyOn(resourceUpdateService.shareResourceService, "shareAll")
+        .mockImplementation(jest.fn);
+
+      const permissionChanges = [
+        {
+          aco: "Resource",
+          aro: "User",
+          aro_foreign_key: pgpKeys.betty.userId,
+          aco_foreign_key: null,
+          type: 1,
+          is_new: true,
+        },
+      ];
+      await resourceUpdateService.exec(
+        resourceDto,
+        plaintextSecretPasswordAndDescriptionDto(),
+        pgpKeys.ada.passphrase,
+        permissionChanges,
+      );
+
+      expect(shareAllSpy).toHaveBeenCalledTimes(1);
+      const [resourcesIds, changesCollection] = shareAllSpy.mock.calls[0];
+      expect(resourcesIds).toEqual([resourceDto.id]);
+      // The delta's aco_foreign_key must be stamped with the resource id before sharing.
+      expect(changesCollection.toDto()[0].aco_foreign_key).toEqual(resourceDto.id);
+    });
+
+    it("Should not call shareAll when no permission changes are provided", async () => {
+      expect.assertions(1);
+
+      const resourceDto = defaultResourceDto();
+      await ResourceLocalStorage.addResource(new ResourceEntity(resourceDto));
+      jest
+        .spyOn(resourceUpdateService.resourceService, "update")
+        .mockImplementation((resourceIdToUpdate, resourceDtoToUpdate) => {
+          const resourceEntity = new ResourceEntity(resourceDto);
+          resourceEntity.secrets = new ResourceSecretsCollection([resourceDtoToUpdate.secrets[0]]);
+          return resourceEntity.toV4Dto(ResourceLocalStorage.DEFAULT_CONTAIN);
+        });
+      const shareAllSpy = jest
+        .spyOn(resourceUpdateService.shareResourceService, "shareAll")
+        .mockImplementation(jest.fn);
+
+      await resourceUpdateService.exec(resourceDto, plaintextSecretPasswordAndDescriptionDto(), pgpKeys.ada.passphrase);
+
+      expect(shareAllSpy).not.toHaveBeenCalled();
+    });
+
     it("Should Update the resource with encrypted secrets (password and description) and dto", async () => {
       expect.assertions(14);
 
@@ -905,33 +965,6 @@ describe("ResourceUpdateService", () => {
       }
     });
 
-    it("Should set personal to true when resource has only 1 user and no groups", async () => {
-      expect.assertions(2);
-
-      const resourceDto = defaultResourceDto();
-      const entity = new ResourceEntity(resourceDto);
-      await ResourceLocalStorage.addResource(entity);
-
-      jest
-        .spyOn(resourceUpdateService.userModel, "findAllIdsForResourceUpdate")
-        .mockImplementationOnce(() => [pgpKeys.ada.userId]);
-      jest.spyOn(PermissionService.prototype, "findAllByAcoForeignKey").mockImplementationOnce(() => []);
-
-      let resourceUpdated;
-      jest
-        .spyOn(resourceUpdateService.resourceService, "update")
-        .mockImplementation((resourceIdToUpdate, resourceDtoToUpdate) => {
-          resourceUpdated = resourceDtoToUpdate;
-          const resourceEntity = new ResourceEntity(resourceDto);
-          return resourceEntity.toV4Dto(ResourceLocalStorage.DEFAULT_CONTAIN);
-        });
-
-      await resourceUpdateService.exec(resourceDto, null, pgpKeys.ada.passphrase);
-
-      expect(resourceUpdated.personal).toBe(true);
-      expect(resourceUpdateService.resourceService.update).toHaveBeenCalledTimes(1);
-    });
-
     it("Should set personal to false when resource has 1 user but is shared with groups", async () => {
       expect.assertions(1);
 

package/src/all/background_page/service/resourceType/getOrFindResourceTypesService.js

@@ -0,0 +1,49 @@
+/**
+ * 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 ResourceTypeLocalStorage from "../local_storage/resourceTypeLocalStorage";
+import ResourceTypeService from "../api/resourceType/resourceTypeService";
+import ResourceTypesCollection from "passbolt-styleguide/src/shared/models/entity/resourceType/resourceTypesCollection";
+
+/**
+ * The service aims to get resource types from the local storage if it is set, or retrieve them from the API and
+ * set the local storage.
+ */
+class GetOrFindResourceTypesService {
+  /**
+   * Constructor.
+   * @param {AccountEntity} account The user account.
+   * @param {ApiClientOptions} apiClientOptions The api client options.
+   */
+  constructor(account, apiClientOptions) {
+    this.resourceTypeService = new ResourceTypeService(apiClientOptions);
+    this.resourceTypeLocalStorage = new ResourceTypeLocalStorage(account);
+  }
+
+  /**
+   * Get or find all resource types.
+   * @returns {Promise<ResourceTypesCollection>}
+   */
+  async getOrFindAll() {
+    const resourceTypesDto = await this.resourceTypeLocalStorage.getData();
+    if (typeof resourceTypesDto !== "undefined") {
+      return new ResourceTypesCollection(resourceTypesDto);
+    }
+    const resourceTypeDtos = await this.resourceTypeService.findAll();
+    const resourceTypesCollection = new ResourceTypesCollection(resourceTypeDtos);
+    await this.resourceTypeLocalStorage.setData(resourceTypesCollection);
+    return resourceTypesCollection;
+  }
+}
+
+export default GetOrFindResourceTypesService;

package/src/all/background_page/service/resourceType/getOrFindResourceTypesService.test.js

@@ -0,0 +1,61 @@
+/**
+ * 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 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 GetOrFindResourceTypesService from "./getOrFindResourceTypesService";
+import ResourceTypeLocalStorage from "../local_storage/resourceTypeLocalStorage";
+import ResourceTypesCollection from "passbolt-styleguide/src/shared/models/entity/resourceType/resourceTypesCollection";
+import { resourceTypesCollectionDto } from "passbolt-styleguide/src/shared/models/entity/resourceType/resourceTypesCollection.test.data";
+
+describe("GetOrFindResourceTypesService", () => {
+  let service, account, storage;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    account = new AccountEntity(defaultAccountDto());
+    service = new GetOrFindResourceTypesService(account, defaultApiClientOptions());
+    storage = new ResourceTypeLocalStorage(account);
+    await storage.flush();
+  });
+
+  describe("::getOrFindAll", () => {
+    it("returns the resource types collection from the local storage on hot cache without delegating to the find-all service.", async () => {
+      expect.assertions(2);
+      const resourceTypesDto = resourceTypesCollectionDto();
+      await storage.setData(new ResourceTypesCollection(resourceTypesDto));
+      jest.spyOn(service.resourceTypeService, "findAll");
+
+      const result = await service.getOrFindAll();
+
+      expect(service.resourceTypeService.findAll).not.toHaveBeenCalled();
+      expect(result.toDto(storage.DEFAULT_CONTAIN)).toEqual(
+        new ResourceTypesCollection(resourceTypesDto).toDto(storage.DEFAULT_CONTAIN),
+      );
+    });
+
+    it("delegates to the find-and-update service on cold cache and returns its result.", async () => {
+      expect.assertions(2);
+      const resourceTypesDto = resourceTypesCollectionDto();
+      const expected = new ResourceTypesCollection(resourceTypesDto);
+      jest.spyOn(service.resourceTypeService, "findAll").mockImplementation(() => expected);
+
+      const result = await service.getOrFindAll();
+
+      expect(service.resourceTypeService.findAll).toHaveBeenCalledTimes(1);
+      expect(result).toStrictEqual(expected);
+    });
+  });
+});