passbolt-browser-extension 5.2.0 → 5.3.2

package/src/all/background_page/service/clipboard/clipboardProviderService.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         5.3.2
+ */
+import "../../../../../test/mocks/mockNavigatorClipboard";
+import ClipboardProviderService from "./clipboardProviderService";
+import BrowserService from "../browser/browserService";
+import EdgeBackgroundPageClipboardService from "../../../../chrome/polyfill/clipboard/edgeBackgroundPageClipboardService";
+
+beforeEach(() => {
+  global.customNavigatorClipboard = undefined;
+});
+
+describe("ClipboardProviderService", () => {
+  describe("::getClipboard", () => {
+    it("should return the customNavigatorClipboard if it is set", async() => {
+      expect.assertions(1);
+
+      const customNavigatorClipboard = {writeText: jest.fn()};
+      global.customNavigatorClipboard = customNavigatorClipboard;
+
+      expect(ClipboardProviderService.getClipboard()).toStrictEqual(customNavigatorClipboard);
+    });
+
+    it("should return the EdgeBackgroundPageClipboardService if not on Firefox and is on MV2", async() => {
+      expect.assertions(1);
+
+      chrome.runtime.getManifest.mockImplementation(() => ({manifest_version: 2}));
+      jest.spyOn(BrowserService, "isFirefox").mockImplementation(() => false);
+
+      expect(ClipboardProviderService.getClipboard()).toStrictEqual(EdgeBackgroundPageClipboardService);
+    });
+
+    it("should return the navigator.clipboard in every other cases: Firefox", async() => {
+      expect.assertions(1);
+
+      chrome.runtime.getManifest.mockImplementation(() => ({manifest_version: 2}));
+      jest.spyOn(BrowserService, "isFirefox").mockImplementation(() => true);
+
+      expect(ClipboardProviderService.getClipboard()).toStrictEqual(navigator.clipboard);
+    });
+
+    it("should return the navigator.clipboard in every other cases: Firefox + mv3", async() => {
+      expect.assertions(1);
+
+      chrome.runtime.getManifest.mockImplementation(() => ({manifest_version: 3}));
+      jest.spyOn(BrowserService, "isFirefox").mockImplementation(() => true);
+
+      expect(ClipboardProviderService.getClipboard()).toStrictEqual(navigator.clipboard);
+    });
+  });
+});

package/src/all/background_page/service/clipboard/copyToClipboardService.js

@@ -0,0 +1,123 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.3.2
+ */
+import {assertString} from "../../utils/assertions";
+import BrowserService from "../browser/browserService";
+import ClipboardProviderService from "./clipboardProviderService";
+
+const CLIPBOARD_TEMPORARY_CONTENT_FLUSH_DELAY_IN_SECOND = 30;
+const CLIPBOARD_TEMPORARY_CONTENT_FLUSH_ALARM = "ClipboardTemporaryContentFlush";
+/**
+ * The service aims to use the clipboard capability on Edge MV2 where:
+ * - navigator.clipboard.writeText cannot be used in Edge MV2 background page due to a focus issue.
+ * - offscreen clipboard cannot be used due to offscreen API available only with MV3.
+ */
+export default class CopyToClipboardService {
+  /**
+   * @constructor
+   */
+  constructor() {
+    this.clipboard = ClipboardProviderService.getClipboard();
+  }
+
+  /**
+   * Copies the given data into the clipboard and sets a timer to remove after 30sec.
+   * @param {string} data
+   * @return {Promise<void>}
+   */
+  async copyTemporarily(data) {
+    assertString(data);
+
+    await this.clearAlarm();
+    await this.clipboard.writeText(data);
+
+    await browser.alarms.create(CopyToClipboardService.ALARM_NAME, {
+      when: Date.now() + CLIPBOARD_TEMPORARY_CONTENT_FLUSH_DELAY_IN_SECOND * 1000
+    });
+  }
+
+  /**
+   * Copies the given data into the clipboard and unsets any flush timer.
+   * @param {string} data
+   * @return {Promise<void>}
+   */
+  async copy(data) {
+    assertString(data);
+
+    await this.clearAlarm();
+    await this.clipboard.writeText(data);
+  }
+
+  /**
+   * Flushes the clipboard if the content is the expected one.
+   * @returns {Promise<void>}
+   */
+  async flushTemporaryContent() {
+    await this.clearAlarm();
+    await this.clipboard.writeText(this._getContentToFlushClipboard());
+  }
+
+  /**
+   * Flushes the clipboard content if there is any temporary content in it.
+   * @returns {Promise<void>}
+   */
+  async flushTemporaryContentIfAny() {
+    const hasTemporaryContent = Boolean(await browser.alarms.get(CopyToClipboardService.ALARM_NAME));
+    if (hasTemporaryContent) {
+      this.flushTemporaryContent();
+    }
+  }
+
+  /**
+   * Removes the flush alarm if any.
+   * @returns {Promise<void>}
+   */
+  async clearAlarm() {
+    await browser.alarms.clear(CopyToClipboardService.ALARM_NAME);
+  }
+
+  /**
+   * Returns a string that the browser can use to clean the clipboard.
+   * The "empty" string depends on the browser.
+   * Chromimum: "" is not accepted but "\x00" does the trick
+   * Firefox: "" is working fine but "\x00" is a bit buggy (the character could be pasted)
+   * @returns {string}
+   * @private
+   */
+  _getContentToFlushClipboard() {
+    return BrowserService.isFirefox()
+      ? ""
+      : "\x00";
+  }
+
+  /**
+   * Flush the current stored passphrase when the PassphraseStorageFlush alarm triggers.
+   * This is a top-level alarm callback
+   * @param {Alarm} alarm
+   * @returns {Promise<void>}
+   */
+  static async handleClipboardTemporaryContentFlushEvent(alarm) {
+    if (alarm.name === CopyToClipboardService.ALARM_NAME) {
+      const clipboardService = new CopyToClipboardService();
+      await clipboardService.flushTemporaryContent();
+    }
+  }
+
+  /**
+   * Returns the PASSPHRASE_FLUSH_ALARM name
+   * @returns {string}
+   */
+  static get ALARM_NAME() {
+    return CLIPBOARD_TEMPORARY_CONTENT_FLUSH_ALARM;
+  }
+}

package/src/all/background_page/service/clipboard/copyToClipboardService.test.js

@@ -0,0 +1,174 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.3.2
+ */
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import CopyToClipboardService from "./copyToClipboardService";
+import "../../../../../test/mocks/mockNavigatorClipboard";
+import "../../../../../test/mocks/mockAlarms";
+
+beforeEach(async() => {
+  jest.clearAllMocks();
+  jest.useFakeTimers();
+  await browser.alarms.clearAll();
+});
+
+describe("CopyToClipboardService", () => {
+  describe("::copyTemporarily", () => {
+    it("should copy the given data into the clipboard and set an alarm", async() => {
+      expect.assertions(5);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      //ensures the test is not blocked by an unmocked promise
+      jest.spyOn(browser.alarms, "create").mockImplementation(() => {});
+      jest.spyOn(browser.alarms, "clear").mockImplementation(() => {});
+
+      const data = "data";
+      await service.copyTemporarily(data);
+
+      expect(await navigator.clipboard.readText()).toStrictEqual(data);
+      expect(browser.alarms.create).toHaveBeenCalledTimes(1);
+      expect(browser.alarms.create).toHaveBeenCalledWith(CopyToClipboardService.ALARM_NAME, {when: Date.now() + 30_000});
+      expect(browser.alarms.clear).toHaveBeenCalledTimes(1);
+      expect(browser.alarms.clear).toHaveBeenCalledWith(CopyToClipboardService.ALARM_NAME);
+    });
+
+    it("should throw an error if the data is not a string", async() => {
+      expect.assertions(1);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      await expect(() => service.copyTemporarily(42)).rejects.toThrowError();
+    });
+  });
+
+  describe("::copy", () => {
+    it("should copy the given data into the clipboard and unset any flush alarm", async() => {
+      expect.assertions(3);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      //ensures the test is not blocked by an unmocked promise
+      jest.spyOn(browser.alarms, "clear").mockImplementation(() => {});
+
+      const data = "data";
+      await service.copy(data);
+
+      expect(await navigator.clipboard.readText()).toStrictEqual(data);
+      expect(browser.alarms.clear).toHaveBeenCalledTimes(1);
+      expect(browser.alarms.clear).toHaveBeenCalledWith(CopyToClipboardService.ALARM_NAME);
+    });
+
+    it("should throw an error if the data is not a string", async() => {
+      expect.assertions(1);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      await expect(() => service.copy(42)).rejects.toThrowError();
+    });
+  });
+
+  describe("::flushTemporaryContent", () => {
+    it("should flush the data in the clipboard", async() => {
+      expect.assertions(1);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      await service.copyTemporarily("data");
+      await service.flushTemporaryContent();
+
+      expect(await navigator.clipboard.readText()).toStrictEqual("\x00");
+    });
+  });
+
+  describe("::flushTemporaryContentIfAny", () => {
+    it("should flush the data in the clipboard if an alarm has been set", async() => {
+      expect.assertions(3);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      jest.spyOn(browser.alarms, "get").mockImplementation(async() => ({test: 42}));
+      jest.spyOn(navigator.clipboard, "writeText").mockImplementation(async() => {});
+
+      await service.copyTemporarily("data");
+      await service.flushTemporaryContentIfAny();
+
+      expect(await navigator.clipboard.writeText).toHaveBeenCalledTimes(2);
+      expect(await navigator.clipboard.writeText).toHaveBeenCalledWith("data");
+      expect(await navigator.clipboard.writeText).toHaveBeenCalledWith("\x00");
+    });
+
+    it("should not flush the data in the clipboard if not alarm has been set", async() => {
+      expect.assertions(2);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+      const clipboardContent = "data";
+
+      jest.spyOn(browser.alarms, "get").mockImplementation(() => null);
+      jest.spyOn(navigator.clipboard, "writeText").mockImplementation(async() => {});
+
+      await service.copy(clipboardContent);
+      await service.flushTemporaryContentIfAny();
+
+      expect(await navigator.clipboard.writeText).toHaveBeenCalledTimes(1);
+      expect(await navigator.clipboard.writeText).toHaveBeenCalledWith(clipboardContent);
+    });
+  });
+
+  describe("::clearAlarm", () => {
+    it("should remove the alarm if any", async() => {
+      expect.assertions(1);
+
+      jest.spyOn(browser.alarms, "clear").mockImplementation(() => {});
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      await service.clearAlarm();
+
+      expect(browser.alarms.clear).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("::handleClipboardTemporaryContentFlushEvent", () => {
+    it("should call to flush the clipboard if the alarm triggers", async() => {
+      expect.assertions(1);
+
+      jest.spyOn(CopyToClipboardService.prototype, "flushTemporaryContent").mockImplementation(() => {});
+
+      const alarm = {name: "ClipboardTemporaryContentFlush"};
+      await CopyToClipboardService.handleClipboardTemporaryContentFlushEvent(alarm);
+
+      expect(CopyToClipboardService.prototype.flushTemporaryContent).toHaveBeenCalledTimes(1);
+    });
+
+    it("should do nothing if the alarm is not the right one", async() => {
+      expect.assertions(1);
+
+      jest.spyOn(CopyToClipboardService.prototype, "flushTemporaryContent").mockImplementation(() => {});
+
+      const alarm = {name: "other-alarm"};
+      await CopyToClipboardService.handleClipboardTemporaryContentFlushEvent(alarm);
+
+      expect(CopyToClipboardService.prototype.flushTemporaryContent).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -12,7 +12,7 @@
  * @since         4.6.0
  */
 import ResourceLocalStorage from "../local_storage/resourceLocalStorage";
-import {assertNumber} from "../../utils/assertions";
+import {assertNumber, assertUuid} from "../../utils/assertions";
 import FindResourcesService from "./findResourcesService";
 import ResourcesCollection from "../../model/entity/resource/resourcesCollection";
 import ResourceTypeModel from "../../model/resourceType/resourceTypeModel";
@@ -113,6 +113,57 @@ class FindAndUpdateResourcesLocalStorage {
     await ResourceLocalStorage.addOrReplaceResourcesCollection(resourcesCollection);
     return resourcesCollection;
   }
+
+  /**
+   * Find and update the local storage with the resources filtered by parent folder id retrieved from the API.
+   * @param {string} parentFolderId The parent folder id to filter the resources with.
+   * @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.
+   * @return {Promise<ResourcesCollection>} The resource shared with the group
+   * @throw {TypeError} If the parentFolderId is not valid UUID
+   */
+  async findAndUpdateAllByParentFolderId(parentFolderId, passphrase = null) {
+    assertUuid(parentFolderId);
+    const resourceTypes = await this.resourceTypeModel.getOrFindAll();
+
+    const apiResourcesCollection = await this.findResourcesServices.findAllByParentFolderIdForLocalStorage(parentFolderId);
+    apiResourcesCollection.filterByResourceTypes(resourceTypes);
+
+    const apiResourcesCollectionMapIds = apiResourcesCollection.items.reduce((result, resource) => {
+      result[resource.id] = resource;
+      return result;
+    }, {});
+
+    const localStorageResourcesCollection = new ResourcesCollection(await ResourceLocalStorage.get(), {validate: false});
+    const knownResourcesCollectionInFolderIds = localStorageResourcesCollection.items.reduce((result, resource) => {
+      if (resource.folderParentId === parentFolderId) {
+        result.push(resource.id);
+      }
+      return result;
+    }, Array(apiResourcesCollection.length));
+
+    apiResourcesCollection.setDecryptedMetadataFromCollection(localStorageResourcesCollection);
+    localStorageResourcesCollection.updateWithCollection(apiResourcesCollection);
+
+    const movedOrRemovedResourcesIds = knownResourcesCollectionInFolderIds.filter(id => !apiResourcesCollectionMapIds[id]);
+    if (movedOrRemovedResourcesIds.length > 0) {
+      const updatedResources = await this.findResourcesServices.findAllByIdsForLocalStorage(movedOrRemovedResourcesIds);
+
+      updatedResources.setDecryptedMetadataFromCollection(localStorageResourcesCollection);
+      localStorageResourcesCollection.updateWithCollection(updatedResources);
+
+      // These resources have been deleted (or permissions revoked) and need to be removed from the local storage.
+      const remainingResourcesIds = movedOrRemovedResourcesIds
+        .filter(id => !updatedResources.getFirstById(id));
+
+      localStorageResourcesCollection.removeMany(remainingResourcesIds);
+    }
+
+    await this.decryptMetadataService.decryptAllFromForeignModels(localStorageResourcesCollection, passphrase, {ignoreDecryptionError: true, updateSessionKeys: true});
+    localStorageResourcesCollection.filterOutMetadataEncrypted();
+
+    await ResourceLocalStorage.set(localStorageResourcesCollection);
+  }
 }
 
 export default FindAndUpdateResourcesLocalStorage;

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

@@ -371,4 +371,104 @@ describe("UpdateResourcesLocalStorage", () => {
       expect(expectLocalStorageResult[1]).toEqual(ResourceEntity.transformDtoFromV4toV5(resourceDto2));
     });
   });
+
+  describe("::findAndUpdateAllByParentFolderId", () => {
+    let service;
+
+    beforeEach(() => {
+      service = new FindAndUpdateResourcesLocalStorage(account, apiClientOptions);
+      jest.spyOn(ResourceTypeService.prototype, "findAll").mockImplementation(() => resourceTypesCollectionDto());
+    });
+
+    it("should extract the id from the resource collection", async() => {
+      expect.assertions(2);
+
+      const parentFolderId = uuidv4();
+
+      const resourcesDto = multipleResourceDtos();
+      jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => resourcesDto);
+      jest.spyOn(service.findResourcesServices, "findAllByParentFolderIdForLocalStorage");
+
+      await service.findAndUpdateAllByParentFolderId(parentFolderId);
+
+      expect(service.findResourcesServices.findAllByParentFolderIdForLocalStorage).toHaveBeenCalledTimes(1);
+      expect(service.findResourcesServices.findAllByParentFolderIdForLocalStorage).toHaveBeenCalledWith(parentFolderId);
+    });
+
+    it("should assert its parameter", async() => {
+      expect.assertions(1);
+      await expect(() => service.findAndUpdateAllByParentFolderId("test")).rejects.toThrow();
+    });
+
+    it("should update the local storage resource collection by removing deleted resources, moving resources and updating resources data", async() => {
+      expect.assertions(8);
+
+      const parentFolderId = uuidv4();
+      const otherParentFolderId = uuidv4();
+
+      /*
+       * Resources collection in local storage:
+       * Resource0.folderParentId = null;
+       * Resource1.folderParentId = parentFolderId; // on API it should be modified only
+       * Resource2.folderParentId = parentFolderId; // on API it should be moved
+       * Resource3.folderParentId = parentFolderId; // on API it should be removed
+       */
+
+      const resourcesDto = multipleResourceDtos();
+      resourcesDto[1].folder_parent_id = parentFolderId;
+      resourcesDto[2].folder_parent_id = parentFolderId;
+      resourcesDto[3].folder_parent_id = parentFolderId;
+
+      delete resourcesDto[0].name;
+      delete resourcesDto[1].name;
+      delete resourcesDto[2].name;
+      delete resourcesDto[3].name;
+
+      const localStorageResourceCollection = new ResourcesCollection(resourcesDto);
+      await ResourceLocalStorage.set(localStorageResourceCollection);
+
+      // the resources in the folder on the API does not have resource2 anymore but resources1 remains and is changed.
+      const apiResourcesDtoInFolder = [
+        {...resourcesDto[1]},
+      ];
+      apiResourcesDtoInFolder[0].metadata.name = "Resource1 - UPDATED";
+      apiResourcesDtoInFolder[0].modified = (new Date()).toISOString();
+
+      // resource2 on the API will be return and updated, resource3 will never be sent back as it is deleted
+      const allIdsApiResourcesDto = [
+        {...resourcesDto[2]},
+      ];
+      allIdsApiResourcesDto[0].folder_parent_id = otherParentFolderId;
+
+      async function mockedFindAllApi(_, filter) {
+        const isParentFolderSearchRequest = Boolean(filter["has-parent"]);
+
+        return isParentFolderSearchRequest
+          ? apiResourcesDtoInFolder
+          : allIdsApiResourcesDto;
+      }
+
+      jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(mockedFindAllApi);
+
+      await service.findAndUpdateAllByParentFolderId(parentFolderId);
+
+      const updatedResourceLocalStorage = new ResourcesCollection(await ResourceLocalStorage.get());
+
+      expect(updatedResourceLocalStorage).toHaveLength(3); //1 resource should be removed compared to the original data
+      const resource0 = updatedResourceLocalStorage.getFirstById(resourcesDto[0].id);
+      expect(resource0.toDto(ResourceEntity.ALL_CONTAIN_OPTIONS)).toStrictEqual(resourcesDto[0]); //this resource should remain unchanged
+
+      const updatedResource1 = updatedResourceLocalStorage.getFirstById(resourcesDto[1].id); // this resource should have been updated but not moved
+      expect(updatedResource1.metadata.name).toStrictEqual("Resource1 - UPDATED");
+      expect(updatedResource1.modified).toStrictEqual(apiResourcesDtoInFolder[0].modified);
+      expect(updatedResource1.folderParentId).toStrictEqual(parentFolderId);
+
+      const updatedResource2 = updatedResourceLocalStorage.getFirstById(resourcesDto[2].id); // this resource should not have changed per say but only moved
+      expect(updatedResource2.modified).toStrictEqual(resourcesDto[2].modified);
+      expect(updatedResource2.folderParentId).toStrictEqual(otherParentFolderId);
+
+      const updatedResource3 = updatedResourceLocalStorage.getFirstById(resourcesDto[3].id); // this resource should have been removed
+      expect(updatedResource3).toBeUndefined();
+    });
+  });
 });

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

@@ -46,18 +46,9 @@ export default class FindResourcesService {
    * @returns {Promise<ResourcesCollection>}
    * @private
    */
-  async findAll(contains, filters, ignoreInvalidEntity) {
-    //Assert contains
-    const supportedOptions = ResourceService.getSupportedContainOptions();
-    const supportedFilter = ResourceService.getSupportedFiltersOptions();
-
-    if (contains && !Object.keys(contains).every(option => supportedOptions.includes(option))) {
-      throw new Error("Unsupported contains parameter used, please check supported contains");
-    }
-
-    if (filters && !Object.keys(filters).every(filter => supportedFilter.includes(filter))) {
-      throw new Error("Unsupported filter parameter used, please check supported filters");
-    }
+  async findAll(contains, filters, ignoreInvalidEntity = false) {
+    this.assertContains(contains);
+    this.assertFilters(filters);
 
     const resourcesDto = await this.resourceService.findAll(contains, filters);
     return new ResourcesCollection(resourcesDto, {clone: false, ignoreInvalidEntity: ignoreInvalidEntity});
@@ -69,7 +60,7 @@ export default class FindResourcesService {
    * @param {Array<string>} resourcesIds
    * @returns {Promise<ResourcesCollection>}
    */
-  async findAllByIds(resourcesIds, contains = {}) {
+  async findAllByIds(resourcesIds, contains = {}, ignoreInvalidEntity = false) {
     assertArrayUUID(resourcesIds);
 
     // We split the requests in chunks in order to avoid any too long url error.
@@ -78,7 +69,7 @@ export default class FindResourcesService {
       const filter = {
         "has-id": resourceIds
       };
-      return async() => await this.findAll(contains, filter);
+      return async() => await this.findAll(contains, filter, ignoreInvalidEntity);
     });
 
     // @todo Later (tm). The Collection should provide this capability, ensuring that validation build rules are executed and performance is guaranteed.
@@ -196,12 +187,8 @@ export default class FindResourcesService {
    */
   async findOneById(resourceId, contains = {}) {
     assertUuid(resourceId);
-    //Assert contains
-    const supportedOptions = ResourceService.getSupportedContainOptions();
+    this.assertContains(contains);
 
-    if (contains && !Object.keys(contains).every(option => supportedOptions.includes(option))) {
-      throw new Error("Unsupported contains parameter used, please check supported contains");
-    }
     const resourcesDto  = await this.resourceService.get(resourceId, contains);
 
     return new ResourceEntity(resourcesDto);
@@ -224,4 +211,51 @@ export default class FindResourcesService {
     const resource = this.findOneById(resourceId, contains);
     return resource;
   }
+
+  /**
+   * Find all the resources matching the given ids for the local storage.
+   * All entities that cannot be validated will be ignored and excluded from the resulting collection.
+   * @param {Array<uuid>} resourceIds
+   * @returns {Promise<ResourcesCollection>}
+   */
+  async findAllByIdsForLocalStorage(resourceIds) {
+    assertArrayUUID(resourceIds);
+    return await this.findAllByIds(resourceIds, ResourceLocalStorage.DEFAULT_CONTAIN, true);
+  }
+
+  /**
+   * Find all the resources having the given parentFolderId as direct ancestor for the local storage
+   * All entities that cannot be validated will be ignored and excluded from the resulting collection.
+   * @param {uuid} parentFolderId
+   * @returns {Promise<ResourcesCollection>}
+   */
+  async findAllByParentFolderIdForLocalStorage(parentFolderId) {
+    assertUuid(parentFolderId);
+    const filters = {"has-parent": parentFolderId};
+    return await this.findAll(ResourceLocalStorage.DEFAULT_CONTAIN, filters, true);
+  }
+
+  /**
+   * Assert the contains to ensure they match the supported ones.
+   * @param {object} contains
+   * @private
+   */
+  assertContains(contains) {
+    const supportedOptions = ResourceService.getSupportedContainOptions();
+    if (contains && !Object.keys(contains).every(option => supportedOptions.includes(option))) {
+      throw new Error("Unsupported contains parameter used, please check supported contains");
+    }
+  }
+
+  /**
+   * Assert the filters to ensure they match the supported ones.
+   * @param {object} filters
+   * @private
+   */
+  assertFilters(filters) {
+    const supportedFilter = ResourceService.getSupportedFiltersOptions();
+    if (filters && !Object.keys(filters).every(filter => supportedFilter.includes(filter))) {
+      throw new Error("Unsupported filter parameter used, please check supported filters");
+    }
+  }
 }