passbolt-browser-extension 5.13.0 → 5.14.2

package/src/all/background_page/service/resource/create/resourceCreateService.js

@@ -12,7 +12,6 @@
  * @since         4.10.0
  */
 
-import FindFoldersService from "../../folder/findFoldersService";
 import { OpenpgpAssertion } from "../../../utils/openpgp/openpgpAssertions";
 import EncryptMessageService from "../../crypto/encryptMessageService";
 import ResourceSecretsCollection from "../../../model/entity/secret/resource/resourceSecretsCollection";
@@ -22,10 +21,12 @@ import ResourceLocalStorage from "../../local_storage/resourceLocalStorage";
 import i18n from "../../../sdk/i18n";
 import ResourceModel from "../../../model/resource/resourceModel";
 import DecryptPrivateKeyService from "../../crypto/decryptPrivateKeyService";
-import ResourceTypeModel from "../../../model/resourceType/resourceTypeModel";
 import EncryptMetadataKeysService from "../../metadata/encryptMetadataService";
 import PermissionChangesCollection from "../../../model/entity/permission/change/permissionChangesCollection";
 import ShareResourceService, { PROGRESS_STEPS_SHARE_RESOURCES_SHARE_ALL } from "../../share/shareResourceService";
+import GetOrFindResourceTypesService from "../../resourceType/getOrFindResourceTypesService";
+import PermissionsCollection from "passbolt-styleguide/src/shared/models/entity/permission/permissionsCollection";
+import PermissionEntity from "passbolt-styleguide/src/shared/models/entity/permission/permissionEntity";
 
 class ResourceCreateService {
   /**
@@ -36,8 +37,7 @@ class ResourceCreateService {
   constructor(account, apiClientOptions, progressService) {
     this.account = account;
     this.resourceService = new ResourceService(apiClientOptions);
-    this.resourceTypeModel = new ResourceTypeModel(apiClientOptions);
-    this.findFoldersService = new FindFoldersService(apiClientOptions);
+    this.getOrFindResourceTypesService = new GetOrFindResourceTypesService(account, apiClientOptions);
     this.progressService = progressService;
     this.resourceModel = new ResourceModel(apiClientOptions, this.account);
     this.encryptMetadataKeysService = new EncryptMetadataKeysService(apiClientOptions, this.account);
@@ -45,34 +45,28 @@ class ResourceCreateService {
   }
 
   /**
-   * Create a resource.
-   *
+   * Create a resource operator-only, then optionally extend the share with the caller-provided
+   * permission changes (spec-mandated safe order: no secret is encrypted for an ARO the caller
+   * hasn't confirmed).
    * @param {object} resourceDto The resource data
    * @param {string|object} secretDto The secret to encrypt
    * @param {string} passphrase The user passphrase
+   * @param {Array<object>} [permissionChanges] Optional permission changes to apply after create.
    * @return {Promise<ResourceEntity>} resourceEntity
    */
-  async create(resourceDto, secretDto, passphrase) {
+  async create(resourceDto, secretDto, passphrase, permissionChanges) {
+    // Port serialization replaces an omitted arg with `null`, sliding past a `= []` default;
+    // normalize defensively so the rest of the method can assume an array.
+    permissionChanges = permissionChanges ?? [];
     const resource = new ResourceEntity(resourceDto);
-    const resourceTypes = await this.resourceTypeModel.getOrFindAll();
+    const resourceTypes = await this.getOrFindResourceTypesService.getOrFindAll();
     const resourceType = resourceTypes.getFirstById(resource.resourceTypeId);
     // Keep a copy of the metadata. It will be used after creation on the API, to persist it decrypted into the local storage.
     const resourceMetadata = resource.metadata;
     // Get private key decrypted to encrypt data
     const privateKey = await DecryptPrivateKeyService.decryptArmoredKey(this.account.userPrivateArmoredKey, passphrase);
-    let permissionChanges = new PermissionChangesCollection([]);
-    let destinationFolder;
-    if (resource.folderParentId) {
-      destinationFolder = await this.findFoldersService.findByIdWithPermissions(resource.folderParentId);
-      if (
-        destinationFolder.permissions.length > 1 ||
-        destinationFolder.permissions.items[0].aroForeignKey !== this.account.userId
-      ) {
-        permissionChanges = destinationFolder.permissions;
-      }
-    }
     this.updateGoals(resourceType.isV5(), permissionChanges.length);
-    await this.encryptMetadata(resource, resourceType, permissionChanges, passphrase);
+    await this.encryptMetadata(resource, resourceType, passphrase);
     await this.buildAndEncryptUserSecret(resource, secretDto, privateKey);
     const createdResource = await this.save(resource, resourceType);
     // If resource v5, metadata will be returned encrypted, replace it with the original decrypted copy.
@@ -80,8 +74,23 @@ class ResourceCreateService {
       createdResource.metadata = resourceMetadata;
     }
     await ResourceLocalStorage.addResource(createdResource);
-    // Share the resource with the metadata decrypted
-    await this.share(createdResource, passphrase, destinationFolder, permissionChanges);
+
+    const isAnOperatorPersonalResource =
+      permissionChanges.length === 1 &&
+      permissionChanges[0].aro === PermissionEntity.ARO_USER &&
+      permissionChanges[0].aro_foreign_key === this.account.userId;
+
+    if (!isAnOperatorPersonalResource && permissionChanges.length > 0) {
+      // The styleguide can't know the resource id at confirm time so the deltas arrive with
+      // aco_foreign_key unset (or null). Stamp the real id before handing them to the share API.
+      const stampedChanges = permissionChanges.map((change) => ({ ...change, aco_foreign_key: createdResource.id }));
+      const originalPermissionSet = new PermissionsCollection([createdResource.permission]);
+      const permissionChangesToApply = PermissionChangesCollection.calculateChanges(
+        originalPermissionSet,
+        new PermissionsCollection(stampedChanges),
+      );
+      await this.shareResourceService.shareAll([createdResource.id], permissionChangesToApply, passphrase);
+    }
     return createdResource;
   }
 
@@ -122,52 +131,33 @@ class ResourceCreateService {
   }
 
   /**
-   * Share the resource.
-   *
-   * @param {ResourceEntity} resource The resource to share.
-   * @param {string} passphrase The user passphrase
-   * @param {FolderEntity} folder The folder entity
-   * @param {PermissionChangesCollection} permissionChangesFromFolder The permission changes
-   * @returns {Promise<void>}
-   * @private
-   */
-  async share(resource, passphrase, folder, permissionChangesFromFolder) {
-    if (!folder || !permissionChangesFromFolder.length) {
-      return;
-    }
-    await this.progressService.finishStep(i18n.t("Calculate permissions"), true);
-    const permissionChanges = await this.resourceModel.calculatePermissionsChangesForCreate(resource, folder);
-    await this.shareResourceService.shareAll([resource.id], permissionChanges, passphrase);
-  }
-
-  /**
-   * Encrypt resource metadata if v5.
+   * Encrypt resource metadata if v5. The resource is always created as `personal` at this stage —
+   * the workflow extends sharing afterwards via `passbolt.share.resources.save`, which re-encrypts
+   * the metadata with the shared key when (and only when) the resource actually gets shared.
    * @param {ResourceEntity} resource The resource
    * @param {ResourceTypeEntity} resourceType The resource type
-   * @param {PermissionChangesCollection} permissionChanges The permission changes
    * @param {string} passphrase The user passphrase
    * @private
    */
-  async encryptMetadata(resource, resourceType, permissionChanges, passphrase) {
+  async encryptMetadata(resource, resourceType, passphrase) {
     if (!resourceType.isV5()) {
       return;
     }
     await this.progressService.finishStep(i18n.t("Encrypting Metadata"), true);
-    resource.personal = !permissionChanges.length;
+    resource.personal = true;
     await this.encryptMetadataKeysService.encryptOneForForeignModel(resource, passphrase);
   }
 
   /**
    * Update goals
    * @param {boolean} shouldEncryptMetadata if metadata should be encrypted
-   * @param {number} changesLength number of permissions changes
+   * @param {number} permissionChangesLength number of permission changes that will be applied after create
    * @private
    */
-  updateGoals(shouldEncryptMetadata, changesLength = 0) {
-    const stepToCreate = shouldEncryptMetadata ? 4 : 3;
-    // 1 inline step ("Calculate permissions") + shareAll's fixed internal steps.
-    const shareSteps = changesLength > 0 ? 1 + PROGRESS_STEPS_SHARE_RESOURCES_SHARE_ALL : 0;
-    this.progressService.updateGoals(stepToCreate + shareSteps);
+  updateGoals(shouldEncryptMetadata, permissionChangesLength = 0) {
+    const stepsToCreate = shouldEncryptMetadata ? 4 : 3;
+    const shareSteps = permissionChangesLength > 0 ? PROGRESS_STEPS_SHARE_RESOURCES_SHARE_ALL : 0;
+    this.progressService.updateGoals(stepsToCreate + shareSteps);
   }
 }
 

package/src/all/background_page/service/resource/create/resourceCreateService.test.js

@@ -28,7 +28,6 @@ import ResourceEntity from "../../../model/entity/resource/resourceEntity";
 import ResourceLocalStorage from "../../local_storage/resourceLocalStorage";
 import Keyring from "../../../model/keyring";
 import ProgressService from "../../progress/progressService";
-import { defaultFolderDto } from "passbolt-styleguide/src/shared/models/entity/folder/folderEntity.test.data";
 import ResourceService from "../../api/resource/resourceService";
 import DecryptMessageService from "../../crypto/decryptMessageService";
 import { OpenpgpAssertion } from "../../../utils/openpgp/openpgpAssertions";
@@ -46,16 +45,11 @@ import {
   plaintextSecretTotpDto,
 } from "passbolt-styleguide/src/shared/models/entity/plaintextSecret/plaintextSecretEntity.test.data";
 import FindFoldersService from "../../folder/findFoldersService";
-import FolderEntity from "../../../model/entity/folder/folderEntity";
 import ShareApiService from "../../api/share/shareApiService";
-import MetadataKeysCollection from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysCollection";
-import { defaultDecryptedSharedMetadataKeysDtos } from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysCollection.test.data";
 import ResourceSecretsCollection from "../../../model/entity/secret/resource/resourceSecretsCollection";
 import DecryptMetadataService from "../../metadata/decryptMetadataService";
 import GetDecryptedUserPrivateKeyService from "../../account/getDecryptedUserPrivateKeyService";
 import { defaultMetadataKeysSettingsDto } from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysSettingsEntity.test.data";
-import { ownerFolderPermissionDto } from "passbolt-styleguide/src/shared/models/entity/permission/permissionEntity.test.data";
-import { mockPassboltResponse } from "passbolt-styleguide/test/mocks/mockApiResponse";
 
 jest.mock("../../../service/progress/progressService");
 
@@ -363,42 +357,94 @@ describe("ResourceCreateService", () => {
       return expect(promise).rejects.toThrow("The secret should be maximum 4096 characters in length.");
     });
 
-    it("Should create the resource into shared folder parent", async () => {
-      expect.assertions(1);
+    it("Should create the resource operator-only and skip the share step when no permissionChanges are passed", async () => {
+      expect.assertions(3);
 
       const folderId = uuidv4();
       const resourceDto = defaultResourceDto({ folder_parent_id: folderId });
-      const shareResourceChanges = {
-        changes: {
-          added: [],
-          removed: [],
-        },
-      };
-
-      jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => mockPassboltResponse([resourceDto]));
+      jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => [resourceDto]);
       jest.spyOn(ResourceService.prototype, "create").mockImplementation(() => resourceDto);
-      jest
-        .spyOn(FindFoldersService.prototype, "findByIdWithPermissions")
-        .mockImplementation(
-          async () => new FolderEntity(defaultFolderDto({ id: folderId }, { withPermissions: true })),
-        );
-      jest.spyOn(ShareApiService.prototype, "simulateShareResource").mockImplementation(() => shareResourceChanges);
-      jest.spyOn(ShareApiService.prototype, "shareFolder").mockImplementation(() => shareResourceChanges);
-      jest.spyOn(ShareApiService.prototype, "shareResource").mockImplementation(() => jest.fn());
+      jest.spyOn(FindFoldersService.prototype, "findByIdWithPermissions");
+      jest.spyOn(ShareApiService.prototype, "shareResource");
+      jest.spyOn(resourceCreateService.shareResourceService, "shareAll");
 
-      jest.spyOn(resourceCreateService, "share");
+      await resourceCreateService.create(
+        resourceDto,
+        plaintextSecretPasswordStringDto().password,
+        pgpKeys.ada.passphrase,
+      );
+
+      // No parent folder permission lookup, no implicit inheritance, no share step — the resource
+      // is created with only the operator's secret encrypted. Sharing is opt-in via the new
+      // `permissionChanges` argument.
+      expect(FindFoldersService.prototype.findByIdWithPermissions).not.toHaveBeenCalled();
+      expect(ShareApiService.prototype.shareResource).not.toHaveBeenCalled();
+      expect(resourceCreateService.shareResourceService.shareAll).not.toHaveBeenCalled();
+    });
+
+    it("Should create the resource operator-only and then run shareResourceService.shareAll when permissionChanges are passed", async () => {
+      expect.assertions(3);
+
+      const folderId = uuidv4();
+      const createdResourceId = uuidv4();
+      const resourceDto = defaultResourceDto({ id: createdResourceId, folder_parent_id: folderId });
+      const operatorId = resourceDto.permission.aro_foreign_key;
+      const otherUserId = uuidv4();
+      const permissionChanges = [
+        {
+          is_new: true,
+          aro: "User",
+          aro_foreign_key: operatorId,
+          aco: "Resource",
+          aco_foreign_key: createdResourceId,
+          type: 1,
+        },
+        {
+          is_new: true,
+          aro: "User",
+          aro_foreign_key: otherUserId,
+          aco: "Resource",
+          aco_foreign_key: createdResourceId,
+          type: 15,
+        },
+      ];
+      jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => [resourceDto]);
+      jest.spyOn(ResourceService.prototype, "create").mockImplementation(() => resourceDto);
+      jest.spyOn(resourceCreateService.shareResourceService, "shareAll").mockImplementation(() => {});
 
       await resourceCreateService.create(
         resourceDto,
         plaintextSecretPasswordStringDto().password,
         pgpKeys.ada.passphrase,
+        permissionChanges,
       );
 
-      expect(resourceCreateService.share).toHaveBeenCalledTimes(1);
+      expect(resourceCreateService.shareResourceService.shareAll).toHaveBeenCalledTimes(1);
+      const [resourcesIds, changesCollection] = resourceCreateService.shareResourceService.shareAll.mock.calls[0];
+      expect(resourcesIds).toEqual([createdResourceId]);
+      // The service wraps the caller's plain DTO list into a PermissionChangesCollection before
+      // handing it to shareAll. We check the aro/aco wiring; `is_new` is implied for new rows and
+      // normalized away by the collection.
+      expect(changesCollection.toDto()).toEqual([
+        expect.objectContaining({
+          aro: "User",
+          aro_foreign_key: operatorId,
+          aco: "Resource",
+          aco_foreign_key: createdResourceId,
+          type: 1,
+        }),
+        expect.objectContaining({
+          aro: "User",
+          aro_foreign_key: otherUserId,
+          aco: "Resource",
+          aco_foreign_key: createdResourceId,
+          type: 15,
+        }),
+      ]);
     });
 
-    it("Should create the resource V5 into shared folder parent", async () => {
-      expect.assertions(5);
+    it("Should create a V5 resource with personal metadata even when the parent folder is shared (workflow re-shares it afterwards)", async () => {
+      expect.assertions(4);
 
       let resourceToAPI, resourceLocalStorageExpected;
       const folderId = uuidv4();
@@ -407,85 +453,55 @@ describe("ResourceCreateService", () => {
         resource_type_id: TEST_RESOURCE_TYPE_V5_DEFAULT,
       });
       const plaintextDto = plaintextSecretPasswordDescriptionTotpDto();
+      const metadataKeysSettingsDto = defaultMetadataKeysSettingsDto();
       const decryptMetadataService = new DecryptMetadataService(apiClientOptions, account);
-      const shareResourceChanges = {
-        changes: {
-          added: [],
-          removed: [],
-        },
-      };
-      const metadataKeysDtos = defaultDecryptedSharedMetadataKeysDtos({ armored_key: pgpKeys.metadataKey.public });
-      const metadataKeys = new MetadataKeysCollection(metadataKeysDtos);
 
+      jest
+        .spyOn(
+          resourceCreateService.encryptMetadataKeysService.getOrFindMetadataSettingsService
+            .findAndUpdateMetadataSettingsLocalStorageService.findMetadataSettingsService
+            .metadataKeysSettingsApiService,
+          "findSettings",
+        )
+        .mockImplementation(() => metadataKeysSettingsDto);
       jest.spyOn(ResourceService.prototype, "create").mockImplementation((resource) => {
-        //Used to check the data sent to API
         resourceToAPI = resource;
         const resourceEntity = new ResourceEntity(resourceDto);
         resourceEntity.secrets = new ResourceSecretsCollection([resourceToAPI.secrets[0]]);
-        resourceEntity.metadataKeyId = resourceToAPI.metadata_key_id;
         resourceEntity.metadataKeyType = resourceToAPI.metadata_key_type;
         resourceLocalStorageExpected = resourceEntity.toDto(ResourceLocalStorage.DEFAULT_CONTAIN);
         resourceEntity.metadata = resourceToAPI.metadata;
         return resourceEntity.toDto(ResourceLocalStorage.DEFAULT_CONTAIN);
       });
-      jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => mockPassboltResponse([resourceDto]));
-      jest
-        .spyOn(FindFoldersService.prototype, "findByIdWithPermissions")
-        .mockImplementation(
-          async () => new FolderEntity(defaultFolderDto({ id: folderId }, { withPermissions: { count: 2 } })),
-        );
-      jest.spyOn(ShareApiService.prototype, "simulateShareResource").mockImplementation(() => shareResourceChanges);
-      jest.spyOn(ShareApiService.prototype, "shareFolder").mockImplementation(() => shareResourceChanges);
-      jest.spyOn(ShareApiService.prototype, "shareResource").mockImplementation(() => jest.fn());
-      jest
-        .spyOn(resourceCreateService.encryptMetadataKeysService.getOrFindMetadataKeysService, "getOrFindAll")
-        .mockImplementation(() => metadataKeys);
-      jest
-        .spyOn(decryptMetadataService.getOrFindMetadataKeysService, "getOrFindAll")
-        .mockImplementation(() => metadataKeys);
-
-      jest.spyOn(resourceCreateService, "share");
+      jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => [resourceDto]);
+      jest.spyOn(FindFoldersService.prototype, "findByIdWithPermissions");
+      jest.spyOn(ShareApiService.prototype, "shareResource");
 
       await resourceCreateService.create(resourceDto, plaintextDto, pgpKeys.ada.passphrase);
 
-      // Decrypt metadata
+      // Decrypt metadata: the resource is created personal, so its metadata is encrypted with the
+      // operator's personal key, not the shared metadata key.
       const resourceEntityUpdated = new ResourceEntity(resourceToAPI);
-      expect(resourceEntityUpdated.isMetadataDecrypted()).toBeFalsy();
-      await decryptMetadataService.decryptOneWithSharedKey(resourceEntityUpdated);
+      const privateKeyDecrypted = await OpenpgpAssertion.readKeyOrFail(pgpKeys.ada.private_decrypted);
+      await decryptMetadataService.decryptMetadataWithGpgKey(resourceEntityUpdated, privateKeyDecrypted);
 
-      expect(resourceCreateService.share).toHaveBeenCalledTimes(1);
-      //Metadata decrypted should be equal
+      expect(FindFoldersService.prototype.findByIdWithPermissions).not.toHaveBeenCalled();
+      expect(ShareApiService.prototype.shareResource).not.toHaveBeenCalled();
       expect(resourceEntityUpdated.metadata.toDto()).toEqual(resourceDto.metadata);
-      // Resource local storage should add the resource
       expect(ResourceLocalStorage.addResource).toHaveBeenCalledWith(new ResourceEntity(resourceLocalStorageExpected));
-      expect(resourceCreateService.progressService.updateGoals).toHaveBeenCalledWith(13);
     });
 
-    it("Should create the resource V5 into personal folder parent", async () => {
-      expect.assertions(6);
+    it("Should call updateGoals with the operator-only step count regardless of whether the parent folder is set", async () => {
+      expect.assertions(1);
 
-      let resourceToAPI, resourceLocalStorageExpected;
       const folderId = uuidv4();
-      const permissionDto = ownerFolderPermissionDto({ aco_foreign_key: folderId, aro_foreign_key: account.userId });
-      const folderDto = defaultFolderDto({ id: folderId, permission: permissionDto, permissions: [permissionDto] });
       const resourceDto = defaultResourceDto({
         folder_parent_id: folderId,
         resource_type_id: TEST_RESOURCE_TYPE_V5_DEFAULT,
       });
       const plaintextDto = plaintextSecretPasswordDescriptionTotpDto();
       const metadataKeysSettingsDto = defaultMetadataKeysSettingsDto();
-      const decryptMetadataService = new DecryptMetadataService(apiClientOptions, account);
 
-      jest.spyOn(ResourceService.prototype, "create").mockImplementation((resource) => {
-        //Used to check the data sent to API
-        resourceToAPI = resource;
-        const resourceEntity = new ResourceEntity(resourceDto);
-        resourceEntity.secrets = new ResourceSecretsCollection([resourceToAPI.secrets[0]]);
-        resourceEntity.metadataKeyType = resourceToAPI.metadata_key_type;
-        resourceLocalStorageExpected = resourceEntity.toDto(ResourceLocalStorage.DEFAULT_CONTAIN);
-        resourceEntity.metadata = resourceToAPI.metadata;
-        return resourceEntity.toDto(ResourceLocalStorage.DEFAULT_CONTAIN);
-      });
       jest
         .spyOn(
           resourceCreateService.encryptMetadataKeysService.getOrFindMetadataSettingsService
@@ -494,30 +510,16 @@ describe("ResourceCreateService", () => {
           "findSettings",
         )
         .mockImplementation(() => metadataKeysSettingsDto);
+      jest.spyOn(ResourceService.prototype, "create").mockImplementation(() => {
+        const resourceEntity = new ResourceEntity(resourceDto);
+        return resourceEntity.toDto(ResourceLocalStorage.DEFAULT_CONTAIN);
+      });
       jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => [resourceDto]);
-      jest
-        .spyOn(FindFoldersService.prototype, "findByIdWithPermissions")
-        .mockImplementation(async () => new FolderEntity(folderDto));
-      jest.spyOn(resourceCreateService.shareResourceService, "shareAll");
-      jest.spyOn(resourceCreateService, "share");
-      //Decrypt secret
-      const decryptionKey = await OpenpgpAssertion.readKeyOrFail(pgpKeys.ada.private_decrypted);
-      jest.spyOn(GetDecryptedUserPrivateKeyService, "getKey").mockImplementationOnce(async () => decryptionKey);
 
       await resourceCreateService.create(resourceDto, plaintextDto, pgpKeys.ada.passphrase);
 
-      // Decrypt metadata
-      const resourceEntityUpdated = new ResourceEntity(resourceToAPI);
-      expect(resourceEntityUpdated.isMetadataDecrypted()).toBeFalsy();
-      const privateKeyDecrypted = await OpenpgpAssertion.readKeyOrFail(pgpKeys.ada.private_decrypted);
-      await decryptMetadataService.decryptMetadataWithGpgKey(resourceEntityUpdated, privateKeyDecrypted);
-
-      expect(resourceCreateService.share).toHaveBeenCalledTimes(1);
-      expect(resourceCreateService.shareResourceService.shareAll).toHaveBeenCalledTimes(0);
-      //Metadata decrypted should be equal
-      expect(resourceEntityUpdated.metadata.toDto()).toEqual(resourceDto.metadata);
-      // Resource local storage should add the resource
-      expect(ResourceLocalStorage.addResource).toHaveBeenCalledWith(new ResourceEntity(resourceLocalStorageExpected));
+      // Operator-only V5: 4 steps (encrypt metadata + encrypt secret + create + local storage),
+      // no share-related steps anymore.
       expect(resourceCreateService.progressService.updateGoals).toHaveBeenCalledWith(4);
     });
   });

package/src/all/background_page/service/resource/export/exportResourcesService.js

@@ -18,13 +18,13 @@ import ExternalResourcesCollection from "../../../model/entity/resource/external
 import ExternalTotpEntity from "../../../model/entity/totp/externalTotpEntity";
 import ResourcesExporter from "../../../model/export/resourcesExporter";
 import FolderModel from "../../../model/folder/folderModel";
-import ResourceTypeModel from "../../../model/resourceType/resourceTypeModel";
 import i18n from "../../../sdk/i18n";
 import DecryptPrivateKeyService from "../../crypto/decryptPrivateKeyService";
 import DecryptMetadataService from "../../metadata/decryptMetadataService";
 import DecryptAndParseResourceSecretService from "../../secret/decryptAndParseResourceSecretService";
 import FindResourcesService from "../findResourcesService";
 import CustomFieldsCollection from "passbolt-styleguide/src/shared/models/entity/customField/customFieldsCollection";
+import GetOrFindResourceTypesService from "../../resourceType/getOrFindResourceTypesService";
 
 /**
  * The service aim to export the resources to a file.
@@ -42,7 +42,7 @@ class ExportResourcesService {
     this.findResourcesService = new FindResourcesService(account, apiClientOptions);
     this.decryptMetadataService = new DecryptMetadataService(apiClientOptions, account);
     // Models
-    this.resourceTypeModel = new ResourceTypeModel(apiClientOptions);
+    this.getOrfindResourceTypesService = new GetOrFindResourceTypesService(account, apiClientOptions);
     this.folderModel = new FolderModel(apiClientOptions, account);
   }
 
@@ -50,12 +50,12 @@ class ExportResourcesService {
    * Export resources to file and return the exported format
    * @param {ExportResourcesFileEntity} exportResourcesFileEntity The export entity
    * @param {String} passphrase the user passphrase
-   * @return {Promise<void>}
+   * @return {Promise<Array>} The custom fields renamed to avoid conflicting with reserved field names
    */
   async exportToFile(exportResourcesFileEntity, passphrase) {
     const privateKey = await DecryptPrivateKeyService.decryptArmoredKey(this.account.userPrivateArmoredKey, passphrase);
     await this.decryptSecrets(exportResourcesFileEntity, privateKey);
-    await this.export(exportResourcesFileEntity);
+    return await this.export(exportResourcesFileEntity);
   }
 
   /**
@@ -94,7 +94,7 @@ class ExportResourcesService {
   async decryptSecrets(exportResourcesFileEntity, privateKey) {
     let i = 0;
 
-    const resourceTypesCollection = await this.resourceTypeModel.getOrFindAll();
+    const resourceTypesCollection = await this.getOrfindResourceTypesService.getOrFindAll();
     for (const exportResourceEntity of exportResourcesFileEntity.exportResources.items) {
       i++;
       await this.progressService.finishStep(
@@ -143,12 +143,12 @@ class ExportResourcesService {
   /**
    * Export
    * @param {ExportResourcesFileEntity} exportResourcesFileEntity The export object
-   * @returns {Promise<void>}
+   * @returns {Promise<Array>} The custom fields renamed to avoid conflicting with reserved field names
    * @private
    */
   async export(exportResourcesFileEntity) {
     const exporter = new ResourcesExporter();
-    await exporter.export(exportResourcesFileEntity);
+    return await exporter.export(exportResourcesFileEntity);
   }
 }
 

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

@@ -15,8 +15,8 @@ import ResourceLocalStorage from "../local_storage/resourceLocalStorage";
 import { assertNumber, assertUuid } from "../../utils/assertions";
 import FindResourcesService from "./findResourcesService";
 import ResourcesCollection from "../../model/entity/resource/resourcesCollection";
-import ResourceTypeModel from "../../model/resourceType/resourceTypeModel";
 import DecryptMetadataService from "../metadata/decryptMetadataService";
+import GetOrFindResourceTypesService from "../resourceType/getOrFindResourceTypesService";
 
 const RESOURCES_UPDATE_ALL_LS_LOCK_PREFIX = "RESOURCES_UPDATE_LS_LOCK_";
 
@@ -39,7 +39,7 @@ class FindAndUpdateResourcesLocalStorage {
   constructor(account, apiClientOptions) {
     this.account = account;
     this.findResourcesServices = new FindResourcesService(account, apiClientOptions);
-    this.resourceTypeModel = new ResourceTypeModel(apiClientOptions);
+    this.getOrFindResourceTypesService = new GetOrFindResourceTypesService(account, apiClientOptions);
     this.decryptMetadataService = new DecryptMetadataService(apiClientOptions, account);
   }
 
@@ -89,7 +89,7 @@ class FindAndUpdateResourcesLocalStorage {
       });
 
       const updatedResourcesCollection = await this.findResourcesServices.findAllForLocalStorage();
-      const resourceTypes = await this.resourceTypeModel.getOrFindAll();
+      const resourceTypes = await this.getOrFindResourceTypesService.getOrFindAll();
       updatedResourcesCollection.filterByResourceTypes(resourceTypes);
       updatedResourcesCollection.setDecryptedMetadataFromCollection(localResourcesCollection);
 
@@ -135,7 +135,7 @@ class FindAndUpdateResourcesLocalStorage {
    */
   async findAndUpdateAllByParentFolderId(parentFolderId, passphrase = null) {
     assertUuid(parentFolderId);
-    const resourceTypes = await this.resourceTypeModel.getOrFindAll();
+    const resourceTypes = await this.getOrFindResourceTypesService.getOrFindAll();
 
     const apiResourcesCollection =
       await this.findResourcesServices.findAllByParentFolderIdForLocalStorage(parentFolderId);

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

@@ -14,13 +14,13 @@
 import ResourceService from "../api/resource/resourceService";
 import ResourceLocalStorage from "../local_storage/resourceLocalStorage";
 import ResourcesCollection from "../../model/entity/resource/resourcesCollection";
-import ResourceTypeModel from "../../model/resourceType/resourceTypeModel";
 import { assertArrayUUID, assertUuid } from "../../utils/assertions";
 import ExecuteConcurrentlyService from "../execute/executeConcurrentlyService";
 import splitBySize from "../../utils/array/splitBySize";
 import ResourceEntity from "../../model/entity/resource/resourceEntity";
 import DecryptMetadataService from "../metadata/decryptMetadataService";
 import { assertNumber } from "passbolt-styleguide/src/shared/utils/assertions";
+import GetOrFindResourceTypesService from "../resourceType/getOrFindResourceTypesService";
 
 const DEFAULT_PAGE_SIZE = 10_000;
 
@@ -36,8 +36,8 @@ export default class FindResourcesService {
   constructor(account, apiClientOptions) {
     this.account = account;
     this.resourceService = new ResourceService(apiClientOptions);
-    this.resourceTypeModel = new ResourceTypeModel(apiClientOptions);
     this.decryptMetadataService = new DecryptMetadataService(apiClientOptions, account);
+    this.getOrFindResourceTypesService = new GetOrFindResourceTypesService(account, apiClientOptions);
   }
 
   /**
@@ -145,7 +145,7 @@ export default class FindResourcesService {
       { "is-shared-with-group": groupId },
       true,
     );
-    const resourceTypes = await this.resourceTypeModel.getOrFindAll();
+    const resourceTypes = await this.getOrFindResourceTypesService.getOrFindAll();
     resources.filterByResourceTypes(resourceTypes);
 
     await this.decryptMetadataService.decryptAllFromForeignModels(resources, passphrase, {
@@ -174,40 +174,37 @@ export default class FindResourcesService {
   }
 
   /**
-   * Retrieve all resources by ids with permissions.
+   * Retrieve resources by ids with their permissions (embedding each permission's user profile or
+   * group), tailored for the share process. The metadata is intentionally not requested nor
+   * decrypted, so no passphrase prompt is triggered.
    * @param {Array<string>} resourcesIds The resource ids to retrieve.
    * @returns {Promise<ResourcesCollection>}
    */
-  async findAllByIdsWithPermissions(resourcesIds) {
+  async findAllPermissionsByIdsForShare(resourcesIds) {
     assertArrayUUID(resourcesIds);
 
     const contains = {
-      permission: true,
-      permissions: true,
+      "permissions.user.profile": true,
+      "permissions.group": true,
     };
 
     return this.findAllByIds(resourcesIds, contains);
   }
 
   /**
-   * Retrieve all resources by ids for display permissions.
+   * Retrieve all resources by ids with permissions.
    * @param {Array<string>} resourcesIds The resource ids to retrieve.
-   * @param {string|null} [passphrase = null] The passphrase to use to decrypt the metadata. Marked as optional as it
-   * might be available in the passphrase session storage.
    * @returns {Promise<ResourcesCollection>}
    */
-  async findAllByIdsForDisplayPermissions(resourcesIds, passphrase = null) {
+  async findAllByIdsWithPermissions(resourcesIds) {
     assertArrayUUID(resourcesIds);
 
     const contains = {
       permission: true,
-      "permissions.user.profile": true,
-      "permissions.group": true,
+      permissions: true,
     };
-    const resources = await this.findAllByIds(resourcesIds, contains);
-    await this.decryptMetadataService.decryptAllFromForeignModels(resources, passphrase);
 
-    return resources;
+    return this.findAllByIds(resourcesIds, contains);
   }
 
   /**