passbolt-browser-extension 5.3.0 → 5.3.2

package/src/all/background_page/service/user/deleteUserService.js

@@ -0,0 +1,97 @@
+/**
+ * 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.4.0
+ */
+import UserService from "../api/user/userService";
+import {assertType, assertUuid} from "../../utils/assertions";
+import DeleteDryRunError from "../../error/deleteDryRunError";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
+import UserDeleteTransferEntity from "../../model/entity/user/transfer/userDeleteTransferEntity";
+import UserLocalStorage from "../local_storage/userLocalStorage";
+
+/**
+ * The service aims to delete user from the API.
+ */
+export default class DeleteUserService {
+  /**
+   *
+   * @param {AccountEntity} account The user account
+   * @param {ApiClientOptions} apiClientOptions The api client options
+   */
+  constructor(account, apiClientOptions) {
+    this.account = account;
+    this.userServiceApi = new UserService(apiClientOptions);
+  }
+
+  /**
+   * Delete dry run a user.
+   * Check if a user can be deleted.
+   *
+   * A user can not be deleted if:
+   * - they are the only owner of a shared resource
+   * - they are the only group manager of a group that owns a shared resource
+   * In such case ownership transfer is required.
+   *
+   * @param {string} userId The user id.
+   * @returns {Promise<void>}
+   * @throws {DeleteDryRunError} if the data should be transferred to someone.
+   * @throws {Error} if the data returned by the API is not a PassboltApiFetchError with error code 400 and groups, resources or folders to transfer.
+   */
+  async deleteDryRun(userId) {
+    assertUuid(userId, "The parameter \"userId\" should be a UUID");
+    try {
+      await this.userServiceApi.delete(userId, {}, true);
+    } catch (error) {
+      await this.handleError(error);
+    }
+  }
+
+  /**
+   * Delete a user and transfer ownership if needed.
+   * @param {string} userId The user id.
+   * @param {UserDeleteTransferEntity} [transfer] optional ownership transfer information if needed.
+   * @returns {Promise<void>}
+   * @throws {DeleteDryRunError} if some permissions must be transferred.
+   * @throws {Error} if the data returned by the API is not a PassboltApiFetchError with error code 400 and groups, resources or folders to transfer.
+   */
+  async delete(userId, transfer) {
+    assertUuid(userId, "The parameter \"userId\" should be a UUID");
+    if (transfer !== null) {
+      assertType(transfer, UserDeleteTransferEntity, 'The `transfer` parameter should be a UserDeleteTransferEntity.');
+    }
+    try {
+      const deleteData = transfer ? transfer.toDto() : {};
+      await this.userServiceApi.delete(userId, deleteData);
+    } catch (error) {
+      await this.handleError(error);
+    }
+    // Update local storage
+    await UserLocalStorage.delete(userId);
+  }
+
+  /**
+   * @private
+   * @param {object} error The error
+   * @throws {DeleteDryRunError} if some permissions must be transferred.
+   * @throws {Error} if the data returned by the API is not a PassboltApiFetchError with error code 400 and groups, resources or folders to transfer.
+   */
+  async handleError(error) {
+    if (error instanceof PassboltApiFetchError && error.data.code === 400 && error.data.body.errors) {
+      /*
+       * recast generic 400 error into a delete dry run error
+       * allowing validation of the returned entities and reuse down the line to transfer permissions
+       */
+      throw new DeleteDryRunError(error.message, error.data.body.errors);
+    }
+    throw error;
+  }
+}

package/src/all/background_page/service/user/deleteUserService.test.js

@@ -0,0 +1,178 @@
+/**
+ * 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.4.0
+ */
+
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import DeleteUserService from "./deleteUserService";
+import {v4 as uuidv4} from "uuid";
+import DeleteDryRunError from "../../error/deleteDryRunError";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
+import UserDeleteTransferEntity from "../../model/entity/user/transfer/userDeleteTransferEntity";
+import {defaultUserDeleteTransferDto} from "passbolt-styleguide/src/shared/models/entity/user/userDeleteTransferEntity.test.data";
+import {defaultResourceDto} from "passbolt-styleguide/src/shared/models/entity/resource/resourceEntity.test.data";
+import UserLocalStorage from "../local_storage/userLocalStorage";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("DeleteUserService", () => {
+  let deleteUserService, apiClientOptions;
+  const account = new AccountEntity(defaultAccountDto());
+
+  beforeEach(async() => {
+    apiClientOptions = defaultApiClientOptions();
+    deleteUserService = new DeleteUserService(account, apiClientOptions);
+  });
+
+  describe("::deleteDryRun", () => {
+    it("Do not need to transfer ownership.", async() => {
+      expect.assertions(1);
+
+      const usersId = uuidv4();
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => {});
+
+      await deleteUserService.deleteDryRun(usersId);
+
+      expect(deleteUserService.userServiceApi.delete).toHaveBeenCalledWith(usersId, {}, true);
+    });
+
+    it("Need to transfer ownership.", async() => {
+      expect.assertions(1);
+
+      const usersId = uuidv4();
+      const resourceDto = defaultResourceDto();
+      const error = {
+        code: 400,
+        body: {
+          errors: {
+            resources: {
+              sole_owner: [resourceDto]
+            }
+          }
+        }
+      };
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => { throw new PassboltApiFetchError("Error", error); });
+
+      try {
+        await deleteUserService.deleteDryRun(usersId);
+      } catch (error) {
+        expect(error).toBeInstanceOf(DeleteDryRunError);
+      }
+    });
+
+    it("throw any error not handled.", async() => {
+      expect.assertions(1);
+
+      const usersId = uuidv4();
+      const error = {
+        code: 404,
+      };
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => { throw new PassboltApiFetchError("Error", error); });
+
+      try {
+        await deleteUserService.deleteDryRun(usersId);
+      } catch (error) {
+        expect(error).toBeInstanceOf(PassboltApiFetchError);
+      }
+    });
+
+    it("throws if user id is not an uuid.", async() => {
+      expect.assertions(1);
+
+      const promise = deleteUserService.deleteDryRun({});
+
+      expect(promise).rejects.toThrow(Error("The parameter \"userId\" should be a UUID"));
+    });
+  });
+
+  describe("::delete", () => {
+    it("delete a user with no transfer.", async() => {
+      expect.assertions(2);
+
+      const usersId = uuidv4();
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => {});
+      jest.spyOn(UserLocalStorage, "delete").mockImplementationOnce(() => {});
+
+      await deleteUserService.delete(usersId, null);
+
+      expect(deleteUserService.userServiceApi.delete).toHaveBeenCalledWith(usersId, {});
+      expect(UserLocalStorage.delete).toHaveBeenCalledWith(usersId);
+    });
+
+    it("delete a user with transfer.", async() => {
+      expect.assertions(2);
+
+      const usersId = uuidv4();
+      const dto = defaultUserDeleteTransferDto();
+      const userDeleteTransfer = new UserDeleteTransferEntity(dto);
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => {});
+      jest.spyOn(UserLocalStorage, "delete").mockImplementationOnce(() => {});
+
+      await deleteUserService.delete(usersId, userDeleteTransfer);
+
+      expect(deleteUserService.userServiceApi.delete).toHaveBeenCalledWith(usersId, dto);
+      expect(UserLocalStorage.delete).toHaveBeenCalledWith(usersId);
+    });
+
+    it("delete a user with an error and need to transfer ownership.", async() => {
+      expect.assertions(1);
+
+      const usersId = uuidv4();
+      const resourceDto = defaultResourceDto();
+      const error = {
+        code: 400,
+        body: {
+          errors: {
+            resources: {
+              sole_owner: [resourceDto]
+            }
+          }
+        }
+      };
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => { throw new PassboltApiFetchError("Error", error); });
+
+      try {
+        await deleteUserService.delete(usersId, null);
+      } catch (error) {
+        expect(error).toBeInstanceOf(DeleteDryRunError);
+      }
+    });
+
+    it("delete a user with an unexpected error.", async() => {
+      expect.assertions(1);
+
+      const usersId = uuidv4();
+      const error = {
+        code: 404,
+      };
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => { throw new PassboltApiFetchError("Error", error); });
+
+      try {
+        await deleteUserService.delete(usersId, null);
+      } catch (error) {
+        expect(error).toBeInstanceOf(PassboltApiFetchError);
+      }
+    });
+
+    it("throws if user id is not an uuid.", async() => {
+      expect.assertions(1);
+
+      const promise = deleteUserService.delete({});
+
+      expect(promise).rejects.toThrow(Error("The parameter \"userId\" should be a UUID"));
+    });
+  });
+});

package/src/chrome/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 2,
   "name": "__MSG_appName__",
   "short_name": "passbolt",
-  "version": "5.3.0",
+  "version": "5.3.2",
   "description": "__MSG_appDescription__",
   "default_locale": "en",
   "externally_connectable": {},

package/src/chrome/polyfill/clipboard/edgeBackgroundPageClipboardService.js

@@ -0,0 +1,31 @@
+/**
+ * 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
+ */
+
+/**
+ * The service aims to create metadata key.
+ */
+export default class EdgeBackgroundPageClipboardService {
+  /**
+   * @inheritDoc navigator.clipboard.writeText
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Clipboard/writeText
+   */
+  static async writeText(data) {
+    const textarea = document.createElement("textarea");
+    document.body.appendChild(textarea);
+    textarea.value = data;
+    textarea.select();
+    document.execCommand("cut");
+    document.body.removeChild(textarea);
+  }
+}

package/src/chrome/polyfill/clipboard/edgeBackgroundPageClipboardService.test.js

@@ -0,0 +1,51 @@
+/**
+ * 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 EdgeBackgroundPageClipboardService from "./edgeBackgroundPageClipboardService";
+
+describe("EdgeBackgroundPageClipboardService", () => {
+  describe("::writeText", () => {
+    it("should write the given data to the clipboard", async() => {
+      expect.assertions(8);
+
+      let copiedValue = "";
+      const fakeElement = {
+        value: "",
+        select: jest.fn().mockImplementation(() => { copiedValue = fakeElement.value; }),
+      };
+      // Faking document for this specific context
+      global.document = {
+        createElement: () => fakeElement,
+        body: {
+          appendChild: jest.fn(),
+          removeChild: jest.fn(),
+        },
+        execCommand: jest.fn()
+      };
+
+      document.execCommand.mockImplementation(() => {});
+
+      const dataToWrite = "text-to-copy";
+      await EdgeBackgroundPageClipboardService.writeText(dataToWrite);
+
+      expect(copiedValue).toStrictEqual(dataToWrite);
+      expect(fakeElement.select).toHaveBeenCalledTimes(1);
+      expect(document.body.appendChild).toHaveBeenCalledTimes(1);
+      expect(document.body.appendChild).toHaveBeenCalledWith(fakeElement);
+      expect(document.body.removeChild).toHaveBeenCalledTimes(1);
+      expect(document.body.removeChild).toHaveBeenCalledWith(fakeElement);
+      expect(document.execCommand).toHaveBeenCalledTimes(1);
+      expect(document.execCommand).toHaveBeenCalledWith("cut");
+    });
+  });
+});

package/src/chrome-mv3/index.js

@@ -18,9 +18,9 @@ import TabService from "../all/background_page/service/tab/tabService";
 import OnExtensionUpdateAvailableService
   from "../all/background_page/service/extension/onExtensionUpdateAvailableService";
 import GlobalAlarmService from "../all/background_page/service/alarm/globalAlarmService";
-import ResponseFetchOffscreenService from "./serviceWorker/service/network/responseFetchOffscreenService";
 import OnStartUpService from "../all/background_page/service/extension/onStartUpService";
 import ToolbarService from "../all/background_page/service/toolbar/toolbarService";
+import HandleOffscreenResponseService from "./serviceWorker/service/offscreen/handleOffscreenResponseService";
 
 /**
  * Load all system requirement
@@ -68,9 +68,9 @@ browser.alarms.onAlarm.removeListener(GlobalAlarmService.exec);
 browser.alarms.onAlarm.addListener(GlobalAlarmService.exec);
 
 /**
- * Handle offscreen fetch responses.
+ * Handle offscreen responses.
  */
-chrome.runtime.onMessage.addListener(ResponseFetchOffscreenService.handleFetchResponse);
+chrome.runtime.onMessage.addListener(HandleOffscreenResponseService.handleOffscreenResponse);
 
 /**
  * Handle suggested resources on toolbar icon

package/src/chrome-mv3/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "name": "__MSG_appName__",
   "short_name": "passbolt",
-  "version": "5.3.0",
+  "version": "5.3.2",
   "description": "__MSG_appDescription__",
   "default_locale": "en",
   "minimum_chrome_version": "116",

package/src/chrome-mv3/offscreens/{fetch.html → offscreen.html}

@@ -3,7 +3,7 @@
 <head>
     <meta charset="utf-8"/>
     <script src="vendors.js"></script>
-    <script src="fetch.js"></script>
+    <script src="offscreen.js"></script>
 </head>
 <body spellcheck="false">
 </body>

package/src/chrome-mv3/offscreens/{fetch.js → offscreen.js}

@@ -12,6 +12,6 @@
  * @since         4.7.0
  */
 
-import FetchOffscreenService from "./service/network/fetchOffscreenService";
+import HandleOffscreenRequestService from "./service/offscreen/handleOffscreenRequestService";
 
-chrome.runtime.onMessage.addListener(FetchOffscreenService.handleFetchRequest);
+chrome.runtime.onMessage.addListener(HandleOffscreenRequestService.handleOffscreenRequest);

package/src/chrome-mv3/offscreens/service/clipboard/writeClipobardOffscreenService.js

@@ -0,0 +1,54 @@
+/**
+ * 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
+ */
+export const SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN = "clipboard-write-offscreen";
+export const SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN_RESPONSE_HANDLER = "service-worker-clipboard-write-text-offscreen-response-handler";
+
+export default class WriteClipobardOffscreenService {
+  /**
+   * Handle clipboard request.
+   * @param {{clipboardContent: string}} message arguments to pass to the clipboard.writeText.
+   * @returns {Promise<object>}
+   */
+  static async handleClipboardRequest({clipboardContent}) {
+    await WriteClipobardOffscreenService._handleClipboardWriteTextRequest(clipboardContent);
+    return WriteClipobardOffscreenService._endClipboardWrite();
+  }
+
+  /**
+   * Handles and emulates a clipboard::writeText(data)
+   * @param {string} clipboardContent
+   * @returns {Promise<void>}
+   * @private
+   */
+  static async _handleClipboardWriteTextRequest(clipboardContent) {
+    const textarea = document.createElement("textarea");
+    document.body.appendChild(textarea);
+    textarea.value = clipboardContent;
+    textarea.select();
+    document.execCommand("cut");
+    document.body.removeChild(textarea);
+  }
+
+  /**
+   * Return the clipboard write success data to send back to the requester.
+   * @returns {object}
+   * @private
+   */
+  static _endClipboardWrite() {
+    return {
+      data: null,
+      target: SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN_RESPONSE_HANDLER,
+    };
+  }
+}

package/src/chrome-mv3/offscreens/service/clipboard/writeClipobardOffscreenService.test.js

@@ -0,0 +1,56 @@
+/**
+ * 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 WriteClipobardOffscreenService from "./writeClipobardOffscreenService";
+
+export const SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN = "clipboard-write-offscreen";
+export const SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN_RESPONSE_HANDLER = "service-worker-clipboard-write-text-offscreen-response-handler";
+
+describe("WriteClipobardOffscreenService", () => {
+  describe("::handleClipboardRequest", () => {
+    it("should run the copy to clipboard and return a message tailored for the requester", async() => {
+      expect.assertions(9);
+
+      let copiedValue = "";
+      const fakeElement = {
+        value: "",
+        select: jest.fn().mockImplementation(() => { copiedValue = fakeElement.value; }),
+      };
+      global.document = {
+        createElement: () => fakeElement,
+        body: {
+          appendChild: jest.fn(),
+          removeChild: jest.fn(),
+        },
+        execCommand: jest.fn()
+      };
+
+      const clipboardContent = "test";
+      const result = await WriteClipobardOffscreenService.handleClipboardRequest({clipboardContent});
+      const expectedResult = {
+        target: "service-worker-clipboard-write-text-offscreen-response-handler",
+        data: null,
+      };
+
+      expect(copiedValue).toStrictEqual(clipboardContent);
+      expect(fakeElement.select).toHaveBeenCalledTimes(1);
+      expect(document.body.appendChild).toHaveBeenCalledTimes(1);
+      expect(document.body.appendChild).toHaveBeenCalledWith(fakeElement);
+      expect(document.body.removeChild).toHaveBeenCalledTimes(1);
+      expect(document.body.removeChild).toHaveBeenCalledWith(fakeElement);
+      expect(document.execCommand).toHaveBeenCalledTimes(1);
+      expect(document.execCommand).toHaveBeenCalledWith("cut");
+      expect(result).toStrictEqual(expectedResult);
+    });
+  });
+});

package/src/chrome-mv3/offscreens/service/network/fetchOffscreenService.js

@@ -11,8 +11,6 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         4.7.0
  */
-
-import Validator from "validator";
 import FormDataUtils from "../../../../all/background_page/utils/format/formDataUtils";
 
 export const SEND_MESSAGE_TARGET_FETCH_OFFSCREEN = "fetch-offscreen";
@@ -43,94 +41,88 @@ export default class FetchOffscreenService {
 
   /**
    * Handle fetch request.
-   * @param {object} message Browser runtime.onMessage listener message.
-   * @returns {Promise<void>}
+   * @param {string} id the request id.
+   * @param {{resource: string, options: object}} data the fetch parameters
+   * @returns {Promise<object>}
    */
-  static async handleFetchRequest(message) {
-    // Return early if this message isn't meant for the offscreen document.
-    if (message.target !== SEND_MESSAGE_TARGET_FETCH_OFFSCREEN) {
-      console.debug("FetchOffscreenService received message not specific to offscreen.");
-      return;
+  static async handleFetchRequest({resource, options}) {
+    const validationErrors = FetchOffscreenService.validateMessageData(resource, options);
+    if (validationErrors) {
+      return validationErrors;
     }
 
-    if (!(await FetchOffscreenService.validateMessageData(message.data))) {
-      return;
-    }
-    const {id, resource, options} = message?.data || {};
     // Update the body to fit the data type to send (JSON or FORM DATA)
-    options.body = options.body.dataType === FETCH_OFFSCREEN_DATA_TYPE_JSON ? options.body.data : FormDataUtils.arrayToFormData(options.body.data);
+    options.body = options.body?.dataType === FETCH_OFFSCREEN_DATA_TYPE_JSON ? options.body.data : FormDataUtils.arrayToFormData(options.body.data);
     await FetchOffscreenService.increaseAwaitingRequests();
     try {
       const response = await fetch(resource, options);
-      await FetchOffscreenService.handleSuccessResponse(id, response);
+      return await FetchOffscreenService.handleSuccessResponse(response);
     } catch (error) {
-      await FetchOffscreenService.handleErrorResponse(id, error);
+      console.log(error);
+      return FetchOffscreenService.handleErrorResponse(error);
+    } finally {
+      await FetchOffscreenService.decreaseAwaitingRequests();
     }
-    await FetchOffscreenService.decreaseAwaitingRequests();
   }
 
   /**
    * Validate message data.
-   * @param {object} messageData The message data
-   * @returns {Promise<boolean>}
+   * @param {string} resource
+   * @param {object} options
+   * @returns {object|null}
    */
-  static async validateMessageData(messageData = {}) {
+  static validateMessageData(resource, options) {
     let error;
-
-    if (!messageData.id || typeof messageData.id !== "string" || !Validator.isUUID(messageData.id)) {
-      error = new Error("FetchOffscreenService: message.id should be a valid uuid.");
-    } else if (typeof messageData.resource !== "string") {
+    if (typeof resource !== "string") {
       error = new Error("FetchOffscreenService: message.resource should be a valid valid.");
-    } else if (typeof messageData.options === "undefined" || !(messageData.options instanceof Object)) {
+    } else if (typeof options === "undefined" || !(options instanceof Object)) {
       error = new Error("FetchOffscreenService: message.options should be an object.");
     }
 
     if (error) {
-      await FetchOffscreenService.handleErrorResponse(messageData.id, error);
-      return false;
+      return FetchOffscreenService.handleErrorResponse(error);
     }
 
-    return true;
+    return null;
   }
 
   /**
    * Handle fetch success, and send response to the service worker.
-   * @param {string} id The fetch offscreen request id
    * @param {Response} response The fetch response
    * @returns {Promise<void>}
+   * @private
    */
-  static async handleSuccessResponse(id, response) {
-    await chrome.runtime.sendMessage({
-      target: SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_RESPONSE_HANDLER,
-      id: id,
+  static async handleSuccessResponse(response) {
+    return {
+      data: await FetchOffscreenService.serializeResponse(response),
       type: FETCH_OFFSCREEN_RESPONSE_TYPE_SUCCESS,
-      data: await FetchOffscreenService.serializeResponse(response)
-    });
+      target: SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_RESPONSE_HANDLER,
+    };
   }
 
   /**
    * Handle fetch error, and communicate it the service worker.
-   * @param {string} id The fetch offscreen request id
    * @param {Error} error The fetch error
-   * @returns {Promise<void>}
+   * @returns {object}
+   * @private
    */
-  static async handleErrorResponse(id, error) {
+  static handleErrorResponse(error) {
     console.error(error);
-    await chrome.runtime.sendMessage({
-      target: SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_RESPONSE_HANDLER,
-      id: id,
-      type: FETCH_OFFSCREEN_RESPONSE_TYPE_ERROR,
+    return {
       data: {
         name: error?.name,
         message: error?.message || "FetchOffscreenService: an unexpected error occurred"
-      }
-    });
+      },
+      type: FETCH_OFFSCREEN_RESPONSE_TYPE_ERROR,
+      target: SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_RESPONSE_HANDLER,
+    };
   }
 
   /**
    * Serialize the fetch response to return to the service worker.
    * @param {Response} response The response to serialize
    * @returns {Promise<object>}
+   * @private
    */
   static async serializeResponse(response) {
     return {