Fix Cloudflare Workers Fetch Illegal Invocation

A shared request wrapper in a Cloudflare Worker can trigger an illegal invocation error when it invokes a stored platform fetch function through the wrong object.

Quick solution:

const safeFetch = globalThis.fetch.bind(globalThis);

Prerequisites include ensuring that any utility wrapping fetch retains its required receiver context before making network requests inside the V8 isolate.

Why Detached Fetch Calls Fail in the Workers Runtime

JavaScript platform methods often rely on internal state tied to their original object. When you destructure fetch or assign it to a property on a custom request wrapper object, the method can lose its intended receiver context. In standard Node test environments, a detached fetch call may succeed because the global environment is less strict. However, the Cloudflare Workers runtime runs in a security-conscious V8 isolate that strictly enforces internal receiver bindings. If the execution context points to your wrapper object instead of globalThis, the engine throws an illegal invocation error.

Consider a scenario where a shared telemetry or routing wrapper stores fetch as an internal property. When the application attempts to read data from an external API, the wrapper executes this.fetch(url). Because this points to the wrapper instance rather than the global scope, the V8 engine rejects the operation.

Implementing the Receiver Fix

To prevent the runtime from rejecting the request, you must explicitly bind the platform function when initializing your utility. This ensures that regardless of how the wrapper calls the method, the internal receiver always points to the correct global object.

export class RequestWrapper {
  private fetchFn: typeof fetch;

  constructor(customFetch: typeof fetch = globalThis.fetch) {
    this.fetchFn = customFetch.bind(globalThis);
  }

  async makeCall(url: string, init?: RequestInit) {
    return this.fetchFn(url, init);
  }
}

By calling customFetch.bind(globalThis), you neutralize any risk of receiver drift caused by method invocation on the wrapper class.

Testing for Receiver Sensitivity

Standard unit tests running under Node.js might pass even if your fetch function loses its receiver. To catch this bug before it hits production, write a receiver-sensitive test double that explicitly checks the value of this during execution.

const strictMockFetch = function(input: RequestInfo | URL, init?: RequestInit) {
  if (this !== globalThis && this !== undefined) {
    throw new TypeError("Illegal invocation: fetch called with incorrect receiver");
  }
  return Promise.resolve(new Response("ok"));
};

When you pass this mock into your wrapper during testing, any incorrect method binding will immediately throw a type error, mirroring the strict behavior of the Cloudflare Workers platform.

Execution and Verification Checklist

• Inspect all shared request wrappers and telemetry utilities for detached fetch assignments.
• Verify that platform functions use explicit binding like globalThis.fetch.bind(globalThis) when stored in object properties.
• Run local tests using a receiver-sensitive mock to confirm that this points correctly to the global scope.
• Deploy the worker to a staging environment and verify that external API calls complete without throwing runtime errors.