egg 3.33.0 → 3.33.1

package/lib/core/utils.js

@@ -7,6 +7,7 @@ const URL = require('url').URL;
 module.exports = {
   convertObject,
   safeParseURL,
+  createTransparentProxy,
 };
 
 function convertObject(obj, ignore, ignoreKeyPaths) {
@@ -90,3 +91,118 @@ function safeParseURL(url) {
     return null;
   }
 }
+
+/**
+ * Create a Proxy that behaves like the real object, but remains transparent to
+ * monkeypatch libraries (e.g. defineProperty-based overrides).
+ *
+ * - Lazily creates the real object on first access.
+ * - Allows overriding properties on the proxy target (overlay) to take effect.
+ * - Delegates everything else to the real object.
+ *
+ * @param {Object} options
+ * @param {Function} options.createReal Create the real object (lazy)
+ * @param {boolean} [options.bindFunctions=true] Bind real methods to the real object
+ * @return {Proxy}
+ */
+function createTransparentProxy({ createReal, bindFunctions = true }) {
+  if (typeof createReal !== 'function') {
+    throw new TypeError('createReal must be a function');
+  }
+
+  let real = null;
+  let error = null;
+  let initialized = false;
+
+  const init = () => {
+    if (initialized) {
+      if (error) throw error;
+      return;
+    }
+    initialized = true;
+    try {
+      real = createReal();
+    } catch (err) {
+      error = err;
+      throw err;
+    }
+  };
+
+  return new Proxy({}, {
+    get(target, prop, receiver) {
+      init();
+      // Check if property is defined on proxy target (monkeypatch overlay)
+      if (Object.getOwnPropertyDescriptor(target, prop)) {
+        return Reflect.get(target, prop, receiver);
+      }
+      const value = real[prop];
+      if (bindFunctions && typeof value === 'function') {
+        return value.bind(real);
+      }
+      return value;
+    },
+
+    set(target, prop, value, receiver) {
+      init();
+      if (Object.getOwnPropertyDescriptor(target, prop)) {
+        return Reflect.set(target, prop, value, receiver);
+      }
+      return Reflect.set(real, prop, value);
+    },
+
+    has(target, prop) {
+      init();
+      return prop in target || prop in real;
+    },
+
+    ownKeys(target) {
+      init();
+      const keys = new Set([ ...Reflect.ownKeys(real), ...Reflect.ownKeys(target) ]);
+      return Array.from(keys);
+    },
+
+    getOwnPropertyDescriptor(target, prop) {
+      init();
+      return Object.getOwnPropertyDescriptor(target, prop)
+        || Object.getOwnPropertyDescriptor(real, prop);
+    },
+
+    deleteProperty(target, prop) {
+      init();
+      if (Object.getOwnPropertyDescriptor(target, prop)) {
+        return delete target[prop];
+      }
+      return delete real[prop];
+    },
+
+    getPrototypeOf() {
+      init();
+      return Object.getPrototypeOf(real);
+    },
+
+    setPrototypeOf(_target, proto) {
+      init();
+      return Reflect.setPrototypeOf(real, proto);
+    },
+
+    isExtensible() {
+      init();
+      return Reflect.isExtensible(real);
+    },
+
+    preventExtensions(target) {
+      init();
+      // Must also prevent extensions on target to satisfy Proxy invariants
+      const result = Reflect.preventExtensions(real);
+      if (result) {
+        Reflect.preventExtensions(target);
+      }
+      return result;
+    },
+
+    defineProperty(target, prop, descriptor) {
+      // Used by monkeypatch libs: keep overrides on proxy target (overlay layer).
+      return Reflect.defineProperty(target, prop, descriptor);
+    },
+  });
+}

package/lib/egg.js

@@ -316,39 +316,10 @@ class EggApplication extends EggCore {
       options.lookup = options.lookup ?? self.config.httpclient.lookup;
       realClient = new self.HttpClientNext(self, options);
     };
-    return new Proxy({}, {
-      get(_target, prop) {
+    return utils.createTransparentProxy({
+      createReal() {
         init();
-        const value = realClient[prop];
-        if (typeof value === 'function') {
-          return value.bind(realClient);
-        }
-        return value;
-      },
-      set(_target, prop, value) {
-        init();
-        realClient[prop] = value;
-        return true;
-      },
-      has(_target, prop) {
-        init();
-        return prop in realClient;
-      },
-      ownKeys() {
-        init();
-        return Reflect.ownKeys(realClient);
-      },
-      getOwnPropertyDescriptor(_target, prop) {
-        init();
-        return Object.getOwnPropertyDescriptor(realClient, prop);
-      },
-      deleteProperty(_target, prop) {
-        init();
-        return delete realClient[prop];
-      },
-      getPrototypeOf() {
-        init();
-        return Object.getPrototypeOf(realClient);
+        return realClient;
       },
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "egg",
-  "version": "3.33.0",
+  "version": "3.33.1",
   "publishConfig": {
     "tag": "release-3.x",
     "access": "public"