Enhance copyExecutionContext with binding prevention

Improved the `copyExecutionContext` utility to prevent re-binding of already bound methods using a proxy. Updated test cases to validate this behavior and added support for `DurableObjectState` as a compatible context type.

Author: cod1k

packages/cloudflare/src/utils/copyExecutionContext.ts

@@ -1,26 +1,42 @@
-import { type ExecutionContext } from '@cloudflare/workers-types';
+import { type DurableObjectState, type ExecutionContext } from '@cloudflare/workers-types';
 
 const kBound = Symbol.for('kBound');
 
+const defaultPropertyOptions: PropertyDescriptor = {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+};
+
 /**
  * Clones the given execution context by creating a shallow copy while ensuring the binding of specific methods.
  *
- * @param {ExecutionContext|void} ctx - The execution context to clone. Can be void.
- * @return {ExecutionContext|void} A cloned execution context with bound methods, or the original void value if no context was provided.
+ * @param {ExecutionContext|DurableObjectState|void} ctx - The execution context to clone. Can be void.
+ * @return {ExecutionContext|DurableObjectState|void} A cloned execution context with bound methods, or the original void value if no context was provided.
  */
-export function copyExecutionContext<T extends ExecutionContext | void>(ctx: T): T {
+export function copyExecutionContext<T extends ExecutionContext | DurableObjectState>(ctx: T): T {
   if (!ctx) return ctx;
-  return Object.assign({}, ctx, {
-    ...('waitUntil' in ctx && { waitUntil: copyBound(ctx, 'waitUntil') }),
-    ...('passThroughOnException' in ctx && { passThroughOnException: copyBound(ctx, 'passThroughOnException') }),
+  return Object.create(ctx, {
+    waitUntil: { ...defaultPropertyOptions, value: copyBound(ctx, 'waitUntil') },
+    ...('passThroughOnException' in ctx && {
+      passThroughOnException: { ...defaultPropertyOptions, value: copyBound(ctx, 'passThroughOnException') },
+    }),
   });
 }
 
-function copyBound<T extends object, K extends keyof T>(obj: T, method: K): T[K] {
+function copyBound<T, K extends keyof T>(obj: T, method: K): T[K] {
   const method_impl = obj[method];
   if (typeof method_impl !== 'function') return method_impl;
   if ((method_impl as T[K] & { [kBound]?: boolean })[kBound]) return method_impl;
 
-  const bound = method_impl.bind(obj);
-  return Object.defineProperty(bound, kBound, { value: true, enumerable: false });
+  return new Proxy(method_impl.bind(obj), {
+    get: (target, key, receiver) => {
+      if ('bind' === key) {
+        return () => receiver;
+      } else if (kBound === key) {
+        return true;
+      }
+      return Reflect.get(target, key, receiver);
+    },
+  });
 }

packages/cloudflare/test/copy-execution-context.test.ts

@@ -17,6 +17,11 @@ describe('Copy of the execution context', () => {
 
       expect(copy[method]()).toBe(context);
     });
+    it('Copied method "rebind" prevention', async () => {
+      const context = makeExecutionContextMock();
+      const copy = copyExecutionContext(context);
+      expect(copy[method].bind('test')).toBe(copy[method]);
+    });
   });
 
   it('No side effects', async () => {