egg 3.33.0 → 3.34.0

package/index.d.ts

@@ -295,6 +295,10 @@ declare module 'egg' {
     maxFreeSockets?: number;
   }
 
+  type Dispatcher = FetchFactory['getDispatcher'] extends () => infer R
+    ? R
+    : never;
+
   /** HttpClient config */
   export interface HttpClientConfig extends HttpClientBaseConfig {
     /** http.Agent */
@@ -319,8 +323,8 @@ declare module 'egg' {
     allowH2?: boolean;
     /** Custom lookup function for DNS resolution */
     lookup?: LookupFunction;
+    interceptors?: Parameters<Dispatcher['compose']>;
   }
-
   export interface EggAppConfig {
     workerStartTimeout: number;
     baseDir: string;

package/lib/core/fetch_factory.js

@@ -3,7 +3,8 @@ const debug = require('util').debuglog('egg:lib:core:fetch_factory');
 const mainNodejsVersion = parseInt(process.versions.node.split('.')[0]);
 let FetchFactory;
 let fetch;
-let fetchInitialized = false;
+// Track initialization per app instance by storing a WeakMap
+const fetchInitializedMap = new WeakMap();
 let safeFetch;
 let ssrfFetchFactory;
 
@@ -14,15 +15,24 @@ if (mainNodejsVersion >= 20) {
     FetchFactory = urllib4.FetchFactory;
     debug('urllib4 enable');
 
-
-    fetch = function fetch(url, init) {
-      if (!fetchInitialized) {
+    fetch = function(url, init) {
+      if (!fetchInitializedMap.get(this)) {
         const clientOptions = {};
         if (this.config.httpclient?.lookup) {
           clientOptions.lookup = this.config.httpclient.lookup;
         }
         FetchFactory.setClientOptions(clientOptions);
-        fetchInitialized = true;
+
+        // Support custom interceptors via dispatcher.compose
+        // Must be set after setClientOptions because setClientOptions resets dispatcher
+        // interceptors is an array of interceptor functions that follow undici's dispatcher API(undici have not supported clientOptions.interceptors natively yet)
+        if (this.config.httpclient?.interceptors) {
+          const interceptors = this.config.httpclient.interceptors;
+          const originalDispatcher = FetchFactory.getDispatcher();
+          FetchFactory.setDispatcher(originalDispatcher.compose(interceptors));
+        }
+
+        fetchInitializedMap.set(this, true);
       }
       return FetchFactory.fetch(url, init);
     };
@@ -41,6 +51,12 @@ if (mainNodejsVersion >= 20) {
         }
         ssrfFetchFactory = new FetchFactory();
         ssrfFetchFactory.setClientOptions(clientOptions);
+
+        if (this.config.httpclient?.interceptors) {
+          const interceptors = this.config.httpclient.interceptors;
+          const originalDispatcher = ssrfFetchFactory.getDispatcher();
+          ssrfFetchFactory.setDispatcher(originalDispatcher.compose(interceptors));
+        }
       }
       return ssrfFetchFactory.fetch(url, init);
     };

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.34.0",
   "publishConfig": {
     "tag": "release-3.x",
     "access": "public"