passbolt-browser-extension 5.13.0 → 5.14.2

package/src/all/background_page/pagemod/quickAccessPagemod.test.js

@@ -19,7 +19,7 @@ import { QuickAccessEvents } from "../event/quickAccessEvents";
 import { GroupEvents } from "../event/groupEvents";
 import { ResourceEvents } from "../event/resourceEvents";
 import { SecretEvents } from "../event/secretEvents";
-import { OrganizationSettingsEvents } from "../event/organizationSettingsEvents";
+import { SiteSettingsEvents } from "../event/siteSettingsEvents";
 import { TabEvents } from "../event/tabEvents";
 import { LocaleEvents } from "../event/localeEvents";
 import { PownedPasswordEvents } from "../event/pownedPasswordEvents";
@@ -38,7 +38,7 @@ jest.spyOn(QuickAccessEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(GroupEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(ResourceEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(SecretEvents, "listen").mockImplementation(jest.fn());
-jest.spyOn(OrganizationSettingsEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(SiteSettingsEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(TabEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(LocaleEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(PownedPasswordEvents, "listen").mockImplementation(jest.fn());
@@ -78,7 +78,7 @@ describe("QuickAccess", () => {
       expect(GroupEvents.listen).toHaveBeenCalledWith(expectedArgument, apiClientOptions, mockedAccount);
       expect(ResourceEvents.listen).toHaveBeenCalledWith(expectedArgument, apiClientOptions, mockedAccount);
       expect(SecretEvents.listen).toHaveBeenCalledWith(expectedArgument, apiClientOptions, mockedAccount);
-      expect(OrganizationSettingsEvents.listen).toHaveBeenCalledWith(expectedArgument, apiClientOptions, mockedAccount);
+      expect(SiteSettingsEvents.listen).toHaveBeenCalledWith(expectedArgument, apiClientOptions, mockedAccount);
       expect(TabEvents.listen).toHaveBeenCalledWith(expectedArgument, apiClientOptions, mockedAccount);
       expect(LocaleEvents.listen).toHaveBeenCalledWith(expectedArgument, apiClientOptions, mockedAccount);
       expect(PownedPasswordEvents.listen).toHaveBeenCalledWith(expectedArgument, apiClientOptions, mockedAccount);
@@ -93,7 +93,7 @@ describe("QuickAccess", () => {
         GroupEvents,
         ResourceEvents,
         SecretEvents,
-        OrganizationSettingsEvents,
+        SiteSettingsEvents,
         TabEvents,
         LocaleEvents,
         PownedPasswordEvents,

package/src/all/background_page/pagemod/recoverPagemod.js

@@ -17,7 +17,7 @@ import { RecoverEvents } from "../event/recoverEvents";
 import BuildAccountRecoverService from "../service/recover/buildAccountRecoverService";
 import BuildApiClientOptionsService from "../service/account/buildApiClientOptionsService";
 import { PownedPasswordEvents } from "../event/pownedPasswordEvents";
-import OrganizationSettingsModel from "../model/organizationSettings/organizationSettingsModel";
+import GetOrFindSiteSettingsService from "../service/siteSettings/getOrFindSiteSettingsService";
 
 class Recover extends Pagemod {
   /**
@@ -45,7 +45,7 @@ class Recover extends Pagemod {
       const tab = port._port.sender.tab;
       const account = BuildAccountRecoverService.buildFromRecoverUrl(tab.url);
       const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
-      await new OrganizationSettingsModel(apiClientOptions).getOrFind(true);
+      await new GetOrFindSiteSettingsService(account, apiClientOptions).getOrFind(true);
       for (const event of this.events) {
         event.listen({ port, tab }, apiClientOptions, account);
       }

package/src/all/background_page/pagemod/recoverPagemod.test.js

@@ -18,6 +18,9 @@ import { ConfigEvents } from "../event/configEvents";
 import BuildApiClientOptionsService from "../service/account/buildApiClientOptionsService";
 import { PownedPasswordEvents } from "../event/pownedPasswordEvents";
 import { enableFetchMocks } from "jest-fetch-mock";
+import { anonymousSiteSettings } from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity.test.data";
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
+import GetOrFindSiteSettingsService from "../service/siteSettings/getOrFindSiteSettingsService";
 
 jest.spyOn(BuildAccountRecoverService, "buildFromRecoverUrl");
 jest.spyOn(BuildApiClientOptionsService, "buildFromAccount");
@@ -30,6 +33,9 @@ describe("Recover", () => {
     jest.resetModules();
     jest.clearAllMocks();
     enableFetchMocks();
+    jest
+      .spyOn(GetOrFindSiteSettingsService.prototype, "getOrFind")
+      .mockImplementation(() => new SiteSettingsEntity(anonymousSiteSettings()));
   });
 
   describe("Recover::attachEvents", () => {

package/src/all/background_page/pagemod/setupPagemod.js

@@ -17,7 +17,7 @@ import BuildApiClientOptionsService from "../service/account/buildApiClientOptio
 import { SetupEvents } from "../event/setupEvents";
 import BuildAccountSetupService from "../service/setup/buildAccountSetupService";
 import { PownedPasswordEvents } from "../event/pownedPasswordEvents";
-import OrganizationSettingsModel from "../model/organizationSettings/organizationSettingsModel";
+import GetOrFindSiteSettingsService from "../service/siteSettings/getOrFindSiteSettingsService";
 
 class Setup extends Pagemod {
   /**
@@ -43,7 +43,7 @@ class Setup extends Pagemod {
       const tab = port._port.sender.tab;
       const account = BuildAccountSetupService.buildFromSetupUrl(tab.url);
       const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
-      await new OrganizationSettingsModel(apiClientOptions).getOrFind(true);
+      await new GetOrFindSiteSettingsService(account, apiClientOptions).getOrFind(true);
       for (const event of this.events) {
         event.listen({ port, tab }, apiClientOptions, account);
       }

package/src/all/background_page/pagemod/setupPagemod.test.js

@@ -18,6 +18,9 @@ import BuildApiClientOptionsService from "../service/account/buildApiClientOptio
 import BuildAccountSetupService from "../service/setup/buildAccountSetupService";
 import { PownedPasswordEvents } from "../event/pownedPasswordEvents";
 import { enableFetchMocks } from "jest-fetch-mock";
+import { anonymousSiteSettings } from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity.test.data";
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
+import GetOrFindSiteSettingsService from "../service/siteSettings/getOrFindSiteSettingsService";
 
 jest.spyOn(BuildAccountSetupService, "buildFromSetupUrl");
 jest.spyOn(BuildApiClientOptionsService, "buildFromAccount");
@@ -30,6 +33,9 @@ describe("Setup", () => {
     jest.resetModules();
     jest.clearAllMocks();
     enableFetchMocks();
+    jest
+      .spyOn(GetOrFindSiteSettingsService.prototype, "getOrFind")
+      .mockImplementation(() => new SiteSettingsEntity(anonymousSiteSettings()));
   });
 
   describe("Setup::attachEvents", () => {

package/src/all/background_page/pagemod/webIntegrationPagemod.js

@@ -14,10 +14,11 @@
 import Pagemod from "./pagemod";
 import { ConfigEvents } from "../event/configEvents";
 import { WebIntegrationEvents } from "../event/webIntegrationEvents";
-import { OrganizationSettingsEvents } from "../event/organizationSettingsEvents";
+import { SiteSettingsEvents } from "../event/siteSettingsEvents";
 import { PortEvents } from "../event/portEvents";
 import ParseWebIntegrationUrlService from "../service/webIntegration/parseWebIntegrationUrlService";
 import GetActiveAccountService from "../service/account/getActiveAccountService";
+import BuildApiClientOptionsService from "../service/account/buildApiClientOptionsService";
 
 class WebIntegration extends Pagemod {
   /**
@@ -49,7 +50,25 @@ class WebIntegration extends Pagemod {
    * @inheritDoc
    */
   get events() {
-    return [ConfigEvents, WebIntegrationEvents, OrganizationSettingsEvents, PortEvents];
+    return [ConfigEvents, WebIntegrationEvents, SiteSettingsEvents, PortEvents];
+  }
+
+  /**
+   * @inheritDoc
+   */
+  async attachEvents(port) {
+    try {
+      const tab = port._port.sender.tab;
+      const account = await GetActiveAccountService.get();
+      const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+      const name = this.appName;
+      for (const event of this.events) {
+        event.listen({ port, tab, name }, apiClientOptions, account);
+      }
+    } catch (error) {
+      // Unexpected error.
+      console.error(error);
+    }
   }
 
   /**

package/src/all/background_page/pagemod/webIntegrationPagemod.test.js

@@ -19,9 +19,12 @@ import WorkerEntity from "../model/entity/worker/workerEntity";
 import ScriptExecution from "../sdk/scriptExecution";
 import Pagemod from "./pagemod";
 import { ConfigEvents } from "../event/configEvents";
-import { OrganizationSettingsEvents } from "../event/organizationSettingsEvents";
+import { SiteSettingsEvents } from "../event/siteSettingsEvents";
 import { WebIntegrationEvents } from "../event/webIntegrationEvents";
 import { PortEvents } from "../event/portEvents";
+import GetActiveAccountService from "../service/account/getActiveAccountService";
+import BuildApiClientOptionsService from "../service/account/buildApiClientOptionsService";
+import { v4 as uuid } from "uuid";
 
 const spyAddWorker = jest.spyOn(WorkersSessionStorage, "addWorker");
 jest.spyOn(ScriptExecution.prototype, "injectPortname").mockImplementation(jest.fn());
@@ -29,7 +32,7 @@ jest.spyOn(ScriptExecution.prototype, "injectCss").mockImplementation(jest.fn())
 jest.spyOn(ScriptExecution.prototype, "injectJs").mockImplementation(jest.fn());
 jest.spyOn(ConfigEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(WebIntegrationEvents, "listen").mockImplementation(jest.fn());
-jest.spyOn(OrganizationSettingsEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(SiteSettingsEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(PortEvents, "listen").mockImplementation(jest.fn());
 
 describe("WebIntegration", () => {
@@ -54,12 +57,7 @@ describe("WebIntegration", () => {
         "contentScripts/js/dist/browser-integration/vendors.js",
         "contentScripts/js/dist/browser-integration/browser-integration.js",
       ]);
-      expect(WebIntegration.events).toStrictEqual([
-        ConfigEvents,
-        WebIntegrationEvents,
-        OrganizationSettingsEvents,
-        PortEvents,
-      ]);
+      expect(WebIntegration.events).toStrictEqual([ConfigEvents, WebIntegrationEvents, SiteSettingsEvents, PortEvents]);
       expect(WebIntegration.mustReloadOnExtensionUpdate).toBeFalsy();
       expect(WebIntegration.appName).toBe("WebIntegration");
     });
@@ -114,29 +112,22 @@ describe("WebIntegration", () => {
           },
         },
       };
+      // mock functions
+      const mockedAccount = { user_id: uuid(), domain: "https://test.passbolt.local" };
+      const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(mockedAccount);
+      jest.spyOn(GetActiveAccountService, "get").mockImplementation(() => mockedAccount);
       // process
       await WebIntegration.attachEvents(port);
       // expectations
-      expect(ConfigEvents.listen).toHaveBeenCalledWith({
-        port: port,
-        tab: port._port.sender.tab,
-        name: WebIntegration.appName,
-      });
-      expect(WebIntegrationEvents.listen).toHaveBeenCalledWith({
-        port: port,
-        tab: port._port.sender.tab,
-        name: WebIntegration.appName,
-      });
-      expect(OrganizationSettingsEvents.listen).toHaveBeenCalledWith({
-        port: port,
-        tab: port._port.sender.tab,
-        name: WebIntegration.appName,
-      });
-      expect(PortEvents.listen).toHaveBeenCalledWith({
+      const expectedWorker = {
         port: port,
         tab: port._port.sender.tab,
         name: WebIntegration.appName,
-      });
+      };
+      expect(ConfigEvents.listen).toHaveBeenCalledWith(expectedWorker, apiClientOptions, mockedAccount);
+      expect(WebIntegrationEvents.listen).toHaveBeenCalledWith(expectedWorker, apiClientOptions, mockedAccount);
+      expect(SiteSettingsEvents.listen).toHaveBeenCalledWith(expectedWorker, apiClientOptions, mockedAccount);
+      expect(PortEvents.listen).toHaveBeenCalledWith(expectedWorker, apiClientOptions, mockedAccount);
     });
   });
 });

package/src/all/background_page/service/account/getActiveAccountService.js

@@ -20,11 +20,10 @@ const ACTIVE_ACCOUNT_KEY = "active-account";
 class GetActiveAccountService {
   /**
    * Get the active account associated with this extension.
-   * @param {Object} options The option to add more data in the account
    * @return {Promise<AccountEntity>}
    * @throw {Error} if no account yet associated with this extension.
    */
-  get(options = {}) {
+  get() {
     return navigator.locks.request(ACTIVE_ACCOUNT_KEY, async () => {
       // Check if the storage have some data
       if (Object.keys(storage._data).length === 0) {
@@ -33,7 +32,7 @@ class GetActiveAccountService {
         // Initialization of the config to get the user information
         Config.init();
       }
-      return await GetLegacyAccountService.get(options);
+      return GetLegacyAccountService.get();
     });
   }
 }

package/src/all/background_page/service/account/getLegacyAccountService.js

@@ -16,31 +16,20 @@ import Keyring from "../../model/keyring";
 import { Uuid } from "../../utils/uuid";
 import AccountEntity from "../../model/entity/account/accountEntity";
 import User from "../../model/user";
-import BuildApiClientOptionsService from "./buildApiClientOptionsService";
-import UserModel from "../../model/user/userModel";
 
 class GetLegacyAccountService {
   /**
    * Get the account associated with this extension.
-   * @param {Object} option The option to add more data in the account
-   * @return {Promise<AccountEntity>}
+   * @return {AccountEntity}
    * @throw {Error} if no account yet associated with this extension.
    */
-  static async get(option = {}) {
+  static get() {
     const keyring = new Keyring();
     const user = User.getInstance().get();
     const serverPublicKeyInfo = keyring.findPublic(Uuid.get(user.settings.domain));
     const userPublicKeyInfo = keyring.findPublic(user.id);
     const userPrivateKeyInfo = keyring.findPrivate();
 
-    // Add in the account the role name if the option object have role (only for authenticated user)
-    let userEntity;
-    if (option?.role) {
-      // Load the application settings, necessary to validate the account username.
-      const apiClientOptions = BuildApiClientOptionsService.buildFromDomain(user.settings.domain);
-      userEntity = await new UserModel(apiClientOptions).findOne(user.id, { role: true });
-    }
-
     const accountDto = {
       domain: user.settings.domain,
       user_id: user.id,
@@ -52,7 +41,7 @@ class GetLegacyAccountService {
       user_public_armored_key: userPublicKeyInfo.armoredKey,
       user_private_armored_key: userPrivateKeyInfo.armoredKey,
       security_token: user.settings.securityToken,
-      role_name: userEntity?.role?.name || null,
+      role_name: null, // This property should be updated later as the user should be authenticated to get his role
     };
 
     /*

package/src/all/background_page/service/account/updateSsoCredentialsService.js

@@ -11,7 +11,7 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         3.9.0
  */
-import OrganizationSettingsModel from "../../model/organizationSettings/organizationSettingsModel";
+import GetOrFindSiteSettingsService from "../siteSettings/getOrFindSiteSettingsService";
 import SsoSettingsModel from "../../model/sso/ssoSettingsModel";
 import SsoDataStorage from "../indexedDB_storage/ssoDataStorage";
 import GenerateSsoKitService from "../sso/generateSsoKitService";
@@ -19,8 +19,12 @@ import SsoKitServerPartModel from "../../model/sso/ssoKitServerPartModel";
 import EntityValidationError from "passbolt-styleguide/src/shared/models/entity/abstract/entityValidationError";
 
 class UpdateSsoCredentialsService {
-  constructor(apiClientOption) {
-    this.organisationSettingsModel = new OrganizationSettingsModel(apiClientOption);
+  /**
+   * @param {ApiClientOptions} apiClientOption the api client options
+   * @param {AccountEntity} account the user account
+   */
+  constructor(apiClientOption, account) {
+    this.getOrFindSiteSettingsService = new GetOrFindSiteSettingsService(account, apiClientOption);
     this.ssoSettingsModel = new SsoSettingsModel(apiClientOption);
     this.ssoKitServerPartModel = new SsoKitServerPartModel(apiClientOption);
   }
@@ -44,8 +48,8 @@ class UpdateSsoCredentialsService {
    */
   async updateSsoKitIfNeeded(passphrase) {
     const localSsoKit = await SsoDataStorage.get();
-    const organizationSettings = await this.organisationSettingsModel.getOrFind();
-    if (!organizationSettings.isPluginEnabled("sso")) {
+    const siteSettings = await this.getOrFindSiteSettingsService.getOrFind(false);
+    if (!siteSettings.isPluginEnabled("sso")) {
       /*
        * If the plugin is disabled there is no reason to keep an SSO kit
        * Plus, if we have an SSO kit locally, the login page will continue display the SSO login

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

@@ -66,21 +66,23 @@ class GroupApiService extends AbstractService {
    * @returns {Array<string>} list of supported option
    */
   static getSupportedFiltersOptions() {
-    return ["has-users", "has-managers", "has-id"];
+    return ["has-users", "has-managers"];
   }
 
   /**
    * Get a group for a given id
    *
    * @param {string} id group uuid
+   * @param {Object} [contains] optional example: { ["groups_users.user.profile"]: true }
    * @throws {Error} if API call fails, service unreachable, etc.
    * @throws {TypeError} if group id is not a valid uuid
-   * @returns {Object} groupDto
+   * @returns {Promise<PassboltResponseEntity>} groupDto
    */
-  async get(id) {
+  async get(id, contains) {
     this.assertValidId(id);
-    const response = await this.apiClient.get(id);
-    return response.body;
+    const options = contains ? this.formatContainOptions(contains, GroupApiService.getSupportedContainOptions()) : null;
+    const response = await this.apiClient.get(id, options);
+    return new PassboltResponseEntity(response);
   }
 
   /**
@@ -93,23 +95,14 @@ class GroupApiService extends AbstractService {
    * @public
    */
   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;
     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 new PassboltResponseEntity(rawResponse);
+    const response = await this.apiClient.findAll(options);
+    return new PassboltResponseEntity(response);
   }
 
   /**

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

@@ -12,7 +12,8 @@
  * @since         2.13.0
  */
 import { enableFetchMocks } from "jest-fetch-mock";
-import { mockApiResponse } from "../../../../../../test/mocks/mockApiResponse";
+import { v4 as uuidv4 } from "uuid";
+import { mockApiResponse, mockApiResponseError } 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";
@@ -25,7 +26,7 @@ beforeEach(() => {
 
 describe("GroupApiService", () => {
   describe("::findAll", () => {
-    it("should return a PassboltResponseEntity containing all groups when no has-id filter is given", async () => {
+    it("should return a PassboltResponseEntity containing all groups", async () => {
       expect.assertions(3);
       const groupsDto = [defaultGroupDto(), defaultGroupDto()];
       fetch.doMockOnceIf(/groups\.json/, () => mockApiResponse(groupsDto));
@@ -37,48 +38,80 @@ describe("GroupApiService", () => {
       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 () => {
+  describe("::get", () => {
+    it("should return a PassboltResponseEntity containing the group for the given id", async () => {
       expect.assertions(3);
-      const group1 = defaultGroupDto();
-      const group2 = defaultGroupDto();
-      const group3 = defaultGroupDto();
-      fetch.doMockOnceIf(/groups\.json/, () => mockApiResponse([group1, group2, group3]));
+      const groupDto = defaultGroupDto();
+      let request;
+      fetch.doMockOnceIf(new RegExp(`/groups/${groupDto.id}.json`), (req) => {
+        request = req;
+        return mockApiResponse(groupDto);
+      });
 
       const service = new GroupApiService(defaultApiClientOptions());
-      const response = await service.findAll(null, { "has-id": [group1.id, group3.id] });
+      const response = await service.get(groupDto.id);
 
       expect(response).toBeInstanceOf(PassboltResponseEntity);
-      expect(response.body).toHaveLength(2);
-      expect(response.body).toStrictEqual([group1, group3]);
+      expect(response.body).toStrictEqual(groupDto);
+      // No contain params should be sent when no contains is given.
+      const containParams = [...new URL(request.url).searchParams.keys()].filter((key) => key.startsWith("contain"));
+      expect(containParams).toStrictEqual([]);
     });
 
-    it("should support a single string value for the has-id filter", async () => {
+    it("should request the given contain options", async () => {
       expect.assertions(3);
-      const group1 = defaultGroupDto();
-      const group2 = defaultGroupDto();
-      fetch.doMockOnceIf(/groups\.json/, () => mockApiResponse([group1, group2]));
+      const groupDto = defaultGroupDto();
+      const contains = { groups_users: true, my_group_user: true, modifier: false };
+      let request;
+      fetch.doMockOnceIf(new RegExp(`/groups/${groupDto.id}.json`), (req) => {
+        request = req;
+        return mockApiResponse(groupDto);
+      });
 
       const service = new GroupApiService(defaultApiClientOptions());
-      const response = await service.findAll(null, { "has-id": group2.id });
+      await service.get(groupDto.id, contains);
 
-      expect(response).toBeInstanceOf(PassboltResponseEntity);
-      expect(response.body).toHaveLength(1);
-      expect(response.body).toStrictEqual([group2]);
+      const url = new URL(request.url);
+      expect(url.searchParams.get("contain[groups_users]")).toStrictEqual("1");
+      expect(url.searchParams.get("contain[my_group_user]")).toStrictEqual("1");
+      expect(url.searchParams.get("contain[modifier]")).toStrictEqual("0");
     });
 
-    it("should return an empty body when no groups match the has-id filter", async () => {
+    it("should ignore unsupported contain options", async () => {
       expect.assertions(2);
-      const group1 = defaultGroupDto();
-      const group2 = defaultGroupDto();
-      fetch.doMockOnceIf(/groups\.json/, () => mockApiResponse([group1, group2]));
+      const groupDto = defaultGroupDto();
+      const contains = { groups_users: true, unsupported_option: true };
+      let request;
+      fetch.doMockOnceIf(new RegExp(`/groups/${groupDto.id}.json`), (req) => {
+        request = req;
+        return mockApiResponse(groupDto);
+      });
 
-      const unrelatedId = defaultGroupDto().id;
       const service = new GroupApiService(defaultApiClientOptions());
-      const response = await service.findAll(null, { "has-id": [unrelatedId] });
+      await service.get(groupDto.id, contains);
 
-      expect(response).toBeInstanceOf(PassboltResponseEntity);
-      expect(response.body).toHaveLength(0);
+      const url = new URL(request.url);
+      expect(url.searchParams.get("contain[groups_users]")).toStrictEqual("1");
+      expect(url.searchParams.has("contain[unsupported_option]")).toStrictEqual(false);
+    });
+
+    it("should throw an error if the API returns a 404", async () => {
+      expect.assertions(1);
+      const groupId = uuidv4();
+      fetch.doMockOnceIf(new RegExp(`/groups/${groupId}.json`), () => mockApiResponseError(404, "Group not found"));
+
+      const service = new GroupApiService(defaultApiClientOptions());
+
+      await expect(service.get(groupId)).rejects.toThrow("Group not found");
+    });
+
+    it("should throw a TypeError if the id is not a valid uuid", async () => {
+      expect.assertions(1);
+      const service = new GroupApiService(defaultApiClientOptions());
+
+      await expect(service.get("not-a-uuid")).rejects.toThrow(TypeError);
     });
   });
 });

package/src/all/background_page/service/api/siteSettings/siteSettingsApiService.js

@@ -0,0 +1,46 @@
+/**
+ * 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 AbstractService from "../abstract/abstractService";
+
+const SITE_SETTINGS_SERVICE_RESOURCE_NAME = "settings";
+
+class SiteSettingsApiService extends AbstractService {
+  /**
+   * @param {ApiClientOptions} apiClientOptions
+   */
+  constructor(apiClientOptions) {
+    super(apiClientOptions, SiteSettingsApiService.RESOURCE_NAME);
+  }
+
+  static get RESOURCE_NAME() {
+    return SITE_SETTINGS_SERVICE_RESOURCE_NAME;
+  }
+
+  /**
+   * Fetch the site settings.
+   * Merges the response server-time header into the dto as `serverTimeDiff` (ms).
+   * @returns {Promise<object>} The site settings dto.
+   */
+  async findSiteSettings() {
+    const response = await this.apiClient.findAll();
+    const dto = JSON.parse(JSON.stringify(response.body));
+    dto.serverTimeDiff = null;
+    if (response.header?.servertime) {
+      dto.serverTimeDiff = response.header.servertime * 1000 - new Date().getTime();
+    }
+    return dto;
+  }
+}
+
+export default SiteSettingsApiService;

package/src/all/background_page/service/api/siteSettings/siteSettingsApiService.test.js

@@ -0,0 +1,63 @@
+/**
+ * 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 { enableFetchMocks } from "jest-fetch-mock";
+import { mockApiResponse, mockApiResponseError } from "passbolt-styleguide/test/mocks/mockApiResponse";
+import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
+import { defaultProSiteSettings } from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity.test.data";
+import SiteSettingsApiService from "./siteSettingsApiService";
+
+beforeEach(() => {
+  enableFetchMocks();
+  fetch.resetMocks();
+  jest.clearAllMocks();
+});
+
+describe("SiteSettingsApiService", () => {
+  describe("::findSiteSettings", () => {
+    it("issues a GET /settings.json request and returns the body", async () => {
+      expect.assertions(3);
+      const expectedDto = defaultProSiteSettings();
+      fetch.doMockOnceIf(/settings\.json/, () => mockApiResponse(expectedDto));
+
+      const service = new SiteSettingsApiService(defaultApiClientOptions());
+      const result = await service.findSiteSettings();
+
+      expect(result.app).toEqual(expectedDto.app);
+      expect(result.passbolt).toEqual(expectedDto.passbolt);
+      expect(result.serverTimeDiff).toBeNull();
+    });
+
+    it("merges the servertime header into serverTimeDiff (ms)", async () => {
+      expect.assertions(1);
+      const expectedDto = defaultProSiteSettings();
+      const nowSec = Math.floor(Date.now() / 1000);
+      const serverAheadSec = nowSec + 60;
+      fetch.doMockOnceIf(/settings\.json/, () => mockApiResponse(expectedDto, { servertime: serverAheadSec }));
+
+      const service = new SiteSettingsApiService(defaultApiClientOptions());
+      const result = await service.findSiteSettings();
+
+      // serverTimeDiff should be positive (server ahead). Allow ~5s of fuzz for test runtime.
+      expect(result.serverTimeDiff).toBeGreaterThan(55_000);
+    });
+
+    it("throws PassboltApiFetchError on API error", async () => {
+      expect.assertions(1);
+      fetch.doMockOnceIf(/settings\.json/, () => mockApiResponseError(500, "boom"));
+      const service = new SiteSettingsApiService(defaultApiClientOptions());
+      await expect(() => service.findSiteSettings()).rejects.toThrow(PassboltApiFetchError);
+    });
+  });
+});