passbolt-browser-extension 5.12.1 → 5.13.0

package/src/all/background_page/service/api/group/groupApiService.js

@@ -12,8 +12,9 @@
  * @since         3.0.0
  */
 import AbstractService from "../abstract/abstractService";
+import PassboltResponseEntity from "passbolt-styleguide/src/shared/models/entity/apiService/PassboltResponseEntity";
 
-const GROUP_SERVICE_RESOURCE_NAME = "groups";
+const GROUP_API_SERVICE_RESOURCE_NAME = "groups";
 
 class GroupApiService extends AbstractService {
   /**
@@ -33,7 +34,7 @@ class GroupApiService extends AbstractService {
    * @public
    */
   static get RESOURCE_NAME() {
-    return GROUP_SERVICE_RESOURCE_NAME;
+    return GROUP_API_SERVICE_RESOURCE_NAME;
   }
 
   /**
@@ -65,16 +66,7 @@ class GroupApiService extends AbstractService {
    * @returns {Array<string>} list of supported option
    */
   static getSupportedFiltersOptions() {
-    return ["has-users", "has-managers"];
-  }
-
-  /**
-   * Return the list of supported orders for in API find operations
-   *
-   * @returns {Array<string>} list of supported option
-   */
-  static getSupportedOrdersOptions() {
-    return ["Group.name DESC", "Group.name ASC"];
+    return ["has-users", "has-managers", "has-id"];
   }
 
   /**
@@ -96,24 +88,28 @@ class GroupApiService extends AbstractService {
    *
    * @param {Object} [contains] optional example: {permissions: true}
    * @param {Object} [filters] optional
-   * @param {Object} [orders] optional
-   * @returns {Promise<*>} response body
+   * @returns {Promise<PassboltResponseEntity>}
    * @throws {Error} if options are invalid or API error
    * @public
    */
-  async findAll(contains, filters, orders) {
+  async findAll(contains, filters) {
+    const hasIdFilter = filters?.["has-id"];
     const legacyContain = GroupApiService.remapLegacyContain(contains); // crassette
     contains = legacyContain
       ? this.formatContainOptions(legacyContain, GroupApiService.getSupportedContainOptions())
       : null;
     filters = filters ? this.formatFilterOptions(filters, GroupApiService.getSupportedFiltersOptions()) : null;
-    orders = orders ? this.formatOrderOptions(orders, GroupApiService.getSupportedFiltersOptions()) : null;
-    const options = { ...contains, ...filters, ...orders };
-    const response = await this.apiClient.findAll(options);
-    if (!response.body || !response.body.length) {
-      return [];
+    const options = { ...contains, ...filters };
+    const rawResponse = await this.apiClient.findAll(options);
+    /*
+     * Ensure backward compatibility with servers that do not yet support the has-id filter:
+     * post-filter the results in memory so the caller always receives only the requested groups.
+     */
+    if (hasIdFilter && rawResponse.body) {
+      const idsMap = new Set(Array.isArray(hasIdFilter) ? hasIdFilter : [hasIdFilter]);
+      rawResponse.body = rawResponse.body.filter((group) => idsMap.has(group.id));
     }
-    return response.body;
+    return new PassboltResponseEntity(rawResponse);
   }
 
   /**
@@ -142,10 +138,13 @@ class GroupApiService extends AbstractService {
    * @throw {TypeError} if group id is not a valid uuid
    * @public
    */
-  async update(groupId, groupData) {
+  async update(groupId, groupData, contains) {
     this.assertValidId(groupId);
     this.assertNonEmptyData(groupData);
-    const response = await this.apiClient.update(groupId, groupData);
+    const urlOptions = contains
+      ? this.formatContainOptions(contains, GroupApiService.getSupportedContainOptions())
+      : {};
+    const response = await this.apiClient.update(groupId, groupData, urlOptions);
     return response.body;
   }
 

package/src/all/background_page/service/api/group/groupApiService.test.js

@@ -11,7 +11,77 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         2.13.0
  */
+import { enableFetchMocks } from "jest-fetch-mock";
+import { mockApiResponse } from "../../../../../../test/mocks/mockApiResponse";
 import GroupApiService from "./groupApiService";
+import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import { defaultGroupDto } from "passbolt-styleguide/src/shared/models/entity/group/groupEntity.test.data";
+import PassboltResponseEntity from "passbolt-styleguide/src/shared/models/entity/apiService/PassboltResponseEntity";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  enableFetchMocks();
+});
+
+describe("GroupApiService", () => {
+  describe("::findAll", () => {
+    it("should return a PassboltResponseEntity containing all groups when no has-id filter is given", async () => {
+      expect.assertions(3);
+      const groupsDto = [defaultGroupDto(), defaultGroupDto()];
+      fetch.doMockOnceIf(/groups\.json/, () => mockApiResponse(groupsDto));
+
+      const service = new GroupApiService(defaultApiClientOptions());
+      const response = await service.findAll();
+
+      expect(response).toBeInstanceOf(PassboltResponseEntity);
+      expect(response.body).toHaveLength(2);
+      expect(response.body).toStrictEqual(groupsDto);
+    });
+
+    it("should post-filter results to only return groups matching the has-id filter", async () => {
+      expect.assertions(3);
+      const group1 = defaultGroupDto();
+      const group2 = defaultGroupDto();
+      const group3 = defaultGroupDto();
+      fetch.doMockOnceIf(/groups\.json/, () => mockApiResponse([group1, group2, group3]));
+
+      const service = new GroupApiService(defaultApiClientOptions());
+      const response = await service.findAll(null, { "has-id": [group1.id, group3.id] });
+
+      expect(response).toBeInstanceOf(PassboltResponseEntity);
+      expect(response.body).toHaveLength(2);
+      expect(response.body).toStrictEqual([group1, group3]);
+    });
+
+    it("should support a single string value for the has-id filter", async () => {
+      expect.assertions(3);
+      const group1 = defaultGroupDto();
+      const group2 = defaultGroupDto();
+      fetch.doMockOnceIf(/groups\.json/, () => mockApiResponse([group1, group2]));
+
+      const service = new GroupApiService(defaultApiClientOptions());
+      const response = await service.findAll(null, { "has-id": group2.id });
+
+      expect(response).toBeInstanceOf(PassboltResponseEntity);
+      expect(response.body).toHaveLength(1);
+      expect(response.body).toStrictEqual([group2]);
+    });
+
+    it("should return an empty body when no groups match the has-id filter", async () => {
+      expect.assertions(2);
+      const group1 = defaultGroupDto();
+      const group2 = defaultGroupDto();
+      fetch.doMockOnceIf(/groups\.json/, () => mockApiResponse([group1, group2]));
+
+      const unrelatedId = defaultGroupDto().id;
+      const service = new GroupApiService(defaultApiClientOptions());
+      const response = await service.findAll(null, { "has-id": [unrelatedId] });
+
+      expect(response).toBeInstanceOf(PassboltResponseEntity);
+      expect(response.body).toHaveLength(0);
+    });
+  });
+});
 
 describe("Group entity", () => {
   it("remap legacy contains", () => {

package/src/all/background_page/service/api/resource/resourceService.js

@@ -10,7 +10,9 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-import AbstractService from "../abstract/abstractService";
+
+import PassboltResponseEntity from "passbolt-styleguide/src/shared/models/entity/apiService/PassboltResponseEntity";
+import AbstractService from "passbolt-styleguide/src/shared/services/api/abstract/abstractService";
 
 const RESOURCE_SERVICE_RESOURCE_NAME = "resources";
 
@@ -82,8 +84,8 @@ class ResourceService extends AbstractService {
    *
    * @returns {Array<string>} list of supported option
    */
-  static getSupportedOrdersOptions() {
-    return ["Resource.modified DESC", "Resource.modified ASC"];
+  static getSupportedSortsOptions() {
+    return ["Resources.modified"];
   }
 
   /**
@@ -107,21 +109,25 @@ class ResourceService extends AbstractService {
    *
    * @param {Object} [contains] optional example: {permissions: true}
    * @param {Object} [filters] optional
-   * @param {Object} [orders] optional
+   * @param {Object} [pageOptions] optional
+   * @param {number} [pageOptions.page] optional
+   * @param {number} [pageOptions.limit] optional
+   * @param {Object} [pageOptions.sorts] optional
+   * @param {Array<string>} [pageOptions.orders] optional
    * @returns {Promise<*>} response body
    * @throws {Error} if options are invalid or API error
    * @public
    */
-  async findAll(contains, filters, orders) {
+  async findAll(contains, filters, pageOptions) {
     contains = contains ? this.formatContainOptions(contains, ResourceService.getSupportedContainOptions()) : null;
     filters = filters ? this.formatFilterOptions(filters, ResourceService.getSupportedFiltersOptions()) : null;
-    orders = orders ? this.formatOrderOptions(orders, ResourceService.getSupportedFiltersOptions()) : null;
-    const options = { ...contains, ...filters, ...orders };
-    const response = await this.apiClient.findAll(options);
-    if (!response.body || !response.body.length) {
-      return [];
-    }
-    return response.body;
+    pageOptions = pageOptions ? this.formatPageOptions(pageOptions, ResourceService.getSupportedSortsOptions()) : null;
+
+    const options = { ...contains, ...filters, ...pageOptions };
+    const responseDto = await this.apiClient.findAll(options);
+
+    const responseDtoBody = !responseDto.body || !responseDto.body.length ? [] : responseDto.body;
+    return new PassboltResponseEntity({ header: responseDto.header, body: responseDtoBody });
   }
 
   /**

package/src/all/background_page/service/api/share/{shareService.js → shareApiService.js}

@@ -13,9 +13,9 @@
 import { assertString } from "../../../utils/assertions";
 import AbstractService from "../abstract/abstractService";
 
-const SHARE_SERVICE_RESOURCE_NAME = "share";
+const SHARE_API_SERVICE_RESOURCE_NAME = "share";
 
-class ShareService extends AbstractService {
+class ShareApiService extends AbstractService {
   /**
    * Constructor
    *
@@ -23,7 +23,7 @@ class ShareService extends AbstractService {
    * @public
    */
   constructor(apiClientOptions) {
-    super(apiClientOptions, ShareService.RESOURCE_NAME);
+    super(apiClientOptions, ShareApiService.RESOURCE_NAME);
   }
 
   /**
@@ -51,7 +51,7 @@ class ShareService extends AbstractService {
    * @public
    */
   static get RESOURCE_NAME() {
-    return SHARE_SERVICE_RESOURCE_NAME;
+    return SHARE_API_SERVICE_RESOURCE_NAME;
   }
 
   /**
@@ -110,8 +110,11 @@ class ShareService extends AbstractService {
    */
   async searchUsersAndGroups(keyword, contains) {
     assertString(keyword, "keyword is not a valid string");
-    const filter = this.formatFilterOptions({ search: keyword }, ShareService.getSupportedSearchArosFiltersOptions());
-    contains = this.formatContainOptions(contains, ShareService.getSupportedSearchArosContainOptions());
+    const filter = this.formatFilterOptions(
+      { search: keyword },
+      ShareApiService.getSupportedSearchArosFiltersOptions(),
+    );
+    contains = this.formatContainOptions(contains, ShareApiService.getSupportedSearchArosContainOptions());
     const options = { ...filter, ...contains };
     const url = "search-aros";
     const response = await this.apiClient.get(url, options);
@@ -119,4 +122,4 @@ class ShareService extends AbstractService {
   }
 }
 
-export default ShareService;
+export default ShareApiService;

package/src/all/background_page/service/api/share/{shareService.test.js → shareApiService.test.js}

@@ -18,7 +18,7 @@ import {
   defaultGroupSearchResultDto,
   defaultUserSearchResultDto,
 } from "../../../model/entity/userAndGroupSearchResultEntity/userAndGroupSearchResultEntity.test.data";
-import ShareService from "./shareService";
+import ShareApiService from "./shareApiService";
 import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
 
 beforeEach(() => {
@@ -26,7 +26,7 @@ beforeEach(() => {
   enableFetchMocks();
 });
 
-describe("ShareService", () => {
+describe("ShareApiService", () => {
   describe("::searchUsersAndGroups", () => {
     it("should return a collection dto from the API", async () => {
       expect.assertions(1);
@@ -38,7 +38,7 @@ describe("ShareService", () => {
       fetch.doMockOnceIf(/share\/search-aros\.json/, () => mockApiResponse(expectedDto));
 
       const keyword = "test";
-      const service = new ShareService(defaultApiClientOptions());
+      const service = new ShareApiService(defaultApiClientOptions());
       const resultDto = await service.searchUsersAndGroups(keyword, contains);
 
       expect(resultDto).toStrictEqual(expectedDto);
@@ -61,7 +61,7 @@ describe("ShareService", () => {
       });
 
       const keyword = "test";
-      const service = new ShareService(defaultApiClientOptions());
+      const service = new ShareApiService(defaultApiClientOptions());
       const resultDto = await service.searchUsersAndGroups(keyword, contains);
 
       expect(resultDto).toStrictEqual(expectedDto);
@@ -70,7 +70,7 @@ describe("ShareService", () => {
     it("should throw an excpetion if the search keyword is empty", async () => {
       expect.assertions(1);
 
-      const service = new ShareService(defaultApiClientOptions());
+      const service = new ShareApiService(defaultApiClientOptions());
       try {
         await service.searchUsersAndGroups(1, {});
       } catch (e) {

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

@@ -14,7 +14,7 @@
 
 import GroupApiService from "../api/group/groupApiService";
 import GroupLocalStorage from "../local_storage/groupLocalStorage";
-import GroupEntity from "../../model/entity/group/groupEntity";
+import GroupEntity from "passbolt-styleguide/src/shared/models/entity/group/groupEntity";
 import { assertType } from "../../utils/assertions";
 
 export default class CreateGroupService {

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

@@ -16,7 +16,7 @@ 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 CreateGroupService from "./createGroupService";
-import GroupEntity from "../../model/entity/group/groupEntity";
+import GroupEntity from "passbolt-styleguide/src/shared/models/entity/group/groupEntity";
 import { defaultGroupDto } from "passbolt-styleguide/src/shared/models/entity/group/groupEntity.test.data";
 
 describe("CreateGroupService", () => {

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

@@ -13,7 +13,10 @@
  */
 import GroupLocalStorage from "../local_storage/groupLocalStorage";
 import FindGroupsService from "./findGroupsService";
-import GroupsCollection from "../../model/entity/group/groupsCollection";
+import GroupApiService from "../api/group/groupApiService";
+import GroupEntity from "passbolt-styleguide/src/shared/models/entity/group/groupEntity";
+import GroupsCollection from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection";
+import { assertArrayUUID } from "../../utils/assertions";
 
 const GROUPS_UPDATE_ALL_LS_LOCK_PREFIX = "GROUPS_UPDATE_LS_LOCK_";
 
@@ -30,6 +33,7 @@ class FindAndUpdateGroupsLocalStorageService {
     this.account = account;
     this.groupLocalStorage = new GroupLocalStorage(account);
     this.findGroupsService = new FindGroupsService(apiClientOptions);
+    this.groupApiService = new GroupApiService(apiClientOptions);
     this.lockKey = `${GROUPS_UPDATE_ALL_LS_LOCK_PREFIX}-${this.account.id}`;
   }
 
@@ -60,6 +64,57 @@ class FindAndUpdateGroupsLocalStorageService {
       return updatedResourcesCollection;
     });
   }
+
+  /**
+   * Retrieve groups from local storage for the given ids.
+   * If any requested group is missing from the local storage, the missing ones are fetched from the API,
+   * added to the local storage, and included in the returned collection.
+   *
+   * @param {Array<string>} groupIds The ids of the groups to retrieve.
+   * @returns {Promise<GroupsCollection>}
+   * @public
+   */
+  async findForLocalStorageByIds(groupIds) {
+    assertArrayUUID(groupIds);
+
+    const groupsDtos = (await this.groupLocalStorage.get()) ?? [];
+    const requestedIdsSet = new Set(groupIds);
+    const collection = new GroupsCollection(
+      groupsDtos.filter((dto) => requestedIdsSet.has(dto.id)),
+      { validate: false },
+    );
+
+    if (collection.length === groupIds.length) {
+      return collection;
+    }
+
+    // Missing groups need to be fetched from the API and stored.
+    // Use a lock to prevent concurrent writes to the local storage.
+    return await navigator.locks.request(this.lockKey, async () => {
+      // Re-check local storage after acquiring the lock, as another concurrent
+      // call may have already fetched and stored the missing groups.
+      const refreshedGroupsDtos = (await this.groupLocalStorage.get()) ?? [];
+      const refreshedCollection = new GroupsCollection(
+        refreshedGroupsDtos.filter((dto) => requestedIdsSet.has(dto.id)),
+        { validate: false },
+      );
+
+      if (refreshedCollection.length === groupIds.length) {
+        return refreshedCollection;
+      }
+
+      const foundIdsSet = new Set(refreshedCollection.items.map((entity) => entity.id));
+      const missingIds = groupIds.filter((id) => !foundIdsSet.has(id));
+      const response = await this.groupApiService.findAll(GroupLocalStorage.DEFAULT_CONTAIN, { "has-id": missingIds });
+      for (const groupDto of response.body ?? []) {
+        const groupEntity = new GroupEntity(groupDto);
+        await this.groupLocalStorage.addGroup(groupEntity);
+        refreshedCollection.push(groupEntity);
+      }
+
+      return refreshedCollection;
+    });
+  }
 }
 
 export default FindAndUpdateGroupsLocalStorageService;

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

@@ -16,8 +16,9 @@ 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 FindAndUpdateGroupsLocalStorageService from "./findAndUpdateGroupsLocalStorageService";
-import GroupsCollection from "../../model/entity/group/groupsCollection";
-import { defaultGroupsDtos } from "../../model/entity/group/groupsCollection.test.data";
+import GroupsCollection from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection";
+import { defaultGroupDto } from "passbolt-styleguide/src/shared/models/entity/group/groupEntity.test.data";
+import { defaultGroupsDtos } from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection.test.data";
 import FindGroupsService from "./findGroupsService";
 
 beforeEach(() => {
@@ -113,4 +114,85 @@ describe("FindAndUpdateGroupsLocalStorageService", () => {
       expect(groupsLSDto).toEqual(groupsDto);
     });
   });
+
+  describe("::findForLocalStorageByIds", () => {
+    it("should return only the requested groups from local storage when all ids are present", async () => {
+      expect.assertions(3);
+
+      const groupsDtos = defaultGroupsDtos(5);
+      const collection = new GroupsCollection(groupsDtos);
+      await findAndUpdateGroupsLocalStorageService.groupLocalStorage.set(collection);
+
+      const requestedIds = [groupsDtos[0].id, groupsDtos[2].id];
+      jest.spyOn(findAndUpdateGroupsLocalStorageService.groupApiService, "findAll");
+
+      const result = await findAndUpdateGroupsLocalStorageService.findForLocalStorageByIds(requestedIds);
+
+      expect(findAndUpdateGroupsLocalStorageService.groupApiService.findAll).not.toHaveBeenCalled();
+      expect(result).toBeInstanceOf(GroupsCollection);
+      expect(result.items.map((g) => g.id)).toStrictEqual(requestedIds);
+    });
+
+    it("should fetch missing groups from the API, add them to local storage, and return the full requested collection", async () => {
+      expect.assertions(5);
+
+      const storedGroupsDtos = defaultGroupsDtos(3);
+      const storedCollection = new GroupsCollection(storedGroupsDtos);
+      await findAndUpdateGroupsLocalStorageService.groupLocalStorage.set(storedCollection);
+
+      const missingGroupDto = defaultGroupDto();
+      jest
+        .spyOn(findAndUpdateGroupsLocalStorageService.groupApiService, "findAll")
+        .mockResolvedValue({ body: [missingGroupDto] });
+
+      const requestedIds = [storedGroupsDtos[0].id, missingGroupDto.id];
+      const result = await findAndUpdateGroupsLocalStorageService.findForLocalStorageByIds(requestedIds);
+
+      expect(findAndUpdateGroupsLocalStorageService.groupApiService.findAll).toHaveBeenCalledTimes(1);
+      expect(findAndUpdateGroupsLocalStorageService.groupApiService.findAll).toHaveBeenCalledWith(
+        { groups_users: true, my_group_user: true },
+        { "has-id": [missingGroupDto.id] },
+      );
+      expect(result).toBeInstanceOf(GroupsCollection);
+      expect(result.items.map((g) => g.id)).toStrictEqual(requestedIds);
+
+      const storageValue = await findAndUpdateGroupsLocalStorageService.groupLocalStorage.get();
+      expect(storageValue.find((dto) => dto.id === missingGroupDto.id)).toBeDefined();
+    });
+
+    it("should not call the API twice when two concurrent calls have the same missing group", async () => {
+      expect.assertions(3);
+
+      const storedGroupsDtos = defaultGroupsDtos(3);
+      const storedCollection = new GroupsCollection(storedGroupsDtos);
+      await findAndUpdateGroupsLocalStorageService.groupLocalStorage.set(storedCollection);
+
+      const missingGroupDto = defaultGroupDto();
+      let resolveApiCall;
+      const apiPromise = new Promise((resolve) => (resolveApiCall = resolve));
+
+      jest
+        .spyOn(findAndUpdateGroupsLocalStorageService.groupApiService, "findAll")
+        .mockImplementationOnce(() => apiPromise);
+
+      const requestedIds = [storedGroupsDtos[0].id, missingGroupDto.id];
+
+      const promise1 = findAndUpdateGroupsLocalStorageService.findForLocalStorageByIds(requestedIds);
+      const promise2 = findAndUpdateGroupsLocalStorageService.findForLocalStorageByIds(requestedIds);
+
+      resolveApiCall({ body: [missingGroupDto] });
+
+      const [result1, result2] = await Promise.all([promise1, promise2]);
+
+      expect(findAndUpdateGroupsLocalStorageService.groupApiService.findAll).toHaveBeenCalledTimes(1);
+      expect(result1.items.map((g) => g.id)).toStrictEqual(requestedIds);
+      expect(result2.items.map((g) => g.id)).toStrictEqual(requestedIds);
+    });
+
+    it("should throw if the parameter is not a valid array of UUIDs", async () => {
+      expect.assertions(1);
+
+      await expect(findAndUpdateGroupsLocalStorageService.findForLocalStorageByIds(["not-a-uuid"])).rejects.toThrow();
+    });
+  });
 });

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

@@ -12,7 +12,7 @@
  * @since         5.7.0
  */
 
-import GroupsCollection from "../../model/entity/group/groupsCollection";
+import GroupsCollection from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection";
 import { assertBoolean, assertType } from "../../utils/assertions";
 import GroupApiService from "../api/group/groupApiService";
 import User from "../../model/user";
@@ -33,23 +33,19 @@ export default class FindGroupsService {
    *
    * @param {Object|null} [contains] optional
    * @param {Object|null} [filters] optional
-   * @param {Object|null} [orders] optional
    * @param {boolean?} [ignoreInvalidEntity] Should invalid entities be ignored.
    * @returns {Promise<GroupsCollection>}
    */
-  async findAll(contains, filters, orders, ignoreInvalidEntity) {
+  async findAll(contains, filters, ignoreInvalidEntity) {
     if (contains) {
       assertType(contains, Object);
     }
     if (filters) {
       assertType(filters, Object);
     }
-    if (orders) {
-      assertType(orders, Object);
-    }
     assertBoolean(ignoreInvalidEntity);
-    const groupsDto = await this.groupApiService.findAll(contains, filters, orders);
-    return new GroupsCollection(groupsDto, { clone: false, ignoreInvalidEntity: ignoreInvalidEntity });
+    const response = await this.groupApiService.findAll(contains, filters);
+    return new GroupsCollection(response.body ?? [], { clone: false, ignoreInvalidEntity: ignoreInvalidEntity });
   }
 
   /**
@@ -72,6 +68,6 @@ export default class FindGroupsService {
    */
   async findAllForLocalStorage() {
     const contains = { groups_users: true, my_group_user: true, modifier: false };
-    return await this.findAll(contains, null, null, true);
+    return await this.findAll(contains, null, true);
   }
 }

package/src/all/background_page/service/group/findGroupsService.test.data.js

@@ -12,7 +12,7 @@
  * @since         5.7.0
  */
 
-import { defaultGroupsDtos } from "../../model/entity/group/groupsCollection.test.data";
+import { defaultGroupsDtos } from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection.test.data";
 
 /**
  * Helper function to generate mock group data for testing.

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

@@ -15,7 +15,7 @@
 import User from "../../model/user";
 import AccountEntity from "../../model/entity/account/accountEntity";
 import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
-import GroupsCollection from "../../model/entity/group/groupsCollection";
+import GroupsCollection from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection";
 import BuildApiClientOptionsService from "../account/buildApiClientOptionsService";
 import FindGroupsService from "./findGroupsService";
 import MockExtension from "../../../../../test/mocks/mockExtension";
@@ -36,40 +36,35 @@ describe("FindGroupsService", () => {
     /**
      * Tests the findAll method of the findGroupsService
      */
-    const testFindAll = async (contains, filters, orders, ignoreInvalidEntity) => {
+    const testFindAll = async (contains, filters, ignoreInvalidEntity) => {
       // Setup mock data for the test
       const groupsDtos = setupMockData();
       // Create a spy on the findAll method of groupApiService and mock its return value
       const spy = jest.spyOn(findGroupsService.groupApiService, "findAll").mockResolvedValue(groupsDtos);
       // Call the findAll method of findGroupsService with the provided parameters
-      const result = await findGroupsService.findAll(contains, filters, orders, ignoreInvalidEntity);
+      const result = await findGroupsService.findAll(contains, filters, ignoreInvalidEntity);
       // Assert that the spy was called with the correct parameters
-      expect(spy).toHaveBeenCalledWith(contains, filters, orders);
+      expect(spy).toHaveBeenCalledWith(contains, filters);
       // Assert that the result is an instance of GroupsCollection
       expect(result).toBeInstanceOf(GroupsCollection);
       // Assert that the result's id matches the mock data's id
       expect(result.id).toBe(groupsDtos.id);
     };
 
-    it("should find groups with contains, filters, and orders", async () => {
-      await testFindAll(
-        { groups_users: true, my_group_user: true, modifier: false },
-        { "has-users": "user123" },
-        { name: "asc" },
-        true,
-      );
+    it("should find groups with contains and filters", async () => {
+      await testFindAll({ groups_users: true, my_group_user: true, modifier: false }, { "has-users": "user123" }, true);
     });
 
     it("should find groups with empty contains, filters, and orders", async () => {
-      await testFindAll({}, {}, {}, true);
+      await testFindAll({}, {}, true);
     });
 
     it("should find groups with null contains, filters, and orders", async () => {
-      await testFindAll(null, null, null, true);
+      await testFindAll(null, null, true);
     });
 
     it("should find groups with ignoreInvalidEntity set to false", async () => {
-      await testFindAll({ groups_users: true, my_group_user: true, modifier: false }, null, null, false);
+      await testFindAll({ groups_users: true, my_group_user: true, modifier: false }, null, false);
     });
 
     /*
@@ -125,7 +120,7 @@ describe("FindGroupsService", () => {
 
       const result = await findGroupsService.findAllForLocalStorage();
 
-      expect(findGroupsService.findAll).toHaveBeenCalledWith(contains, null, null, true);
+      expect(findGroupsService.findAll).toHaveBeenCalledWith(contains, null, true);
       expect(result).toBeInstanceOf(Array);
       expect(result.id).toBe(groupsDtos.id);
     });