undici 7.15.0 → 7.16.0

package/lib/dispatcher/pool-base.js

@@ -18,54 +18,55 @@ const kAddClient = Symbol('add client')
 const kRemoveClient = Symbol('remove client')
 
 class PoolBase extends DispatcherBase {
-  constructor () {
-    super()
+  [kQueue] = new FixedQueue();
 
-    this[kQueue] = new FixedQueue()
-    this[kClients] = []
-    this[kQueued] = 0
+  [kQueued] = 0;
 
-    const pool = this
+  [kClients] = [];
 
-    this[kOnDrain] = function onDrain (origin, targets) {
-      const queue = pool[kQueue]
+  [kNeedDrain] = false;
 
-      let needDrain = false
+  [kOnDrain] (client, origin, targets) {
+    const queue = this[kQueue]
 
-      while (!needDrain) {
-        const item = queue.shift()
-        if (!item) {
-          break
-        }
-        pool[kQueued]--
-        needDrain = !this.dispatch(item.opts, item.handler)
+    let needDrain = false
+
+    while (!needDrain) {
+      const item = queue.shift()
+      if (!item) {
+        break
       }
+      this[kQueued]--
+      needDrain = !client.dispatch(item.opts, item.handler)
+    }
 
-      this[kNeedDrain] = needDrain
+    client[kNeedDrain] = needDrain
 
-      if (!this[kNeedDrain] && pool[kNeedDrain]) {
-        pool[kNeedDrain] = false
-        pool.emit('drain', origin, [pool, ...targets])
-      }
+    if (!needDrain && this[kNeedDrain]) {
+      this[kNeedDrain] = false
+      this.emit('drain', origin, [this, ...targets])
+    }
 
-      if (pool[kClosedResolve] && queue.isEmpty()) {
-        Promise
-          .all(pool[kClients].map(c => c.close()))
-          .then(pool[kClosedResolve])
+    if (this[kClosedResolve] && queue.isEmpty()) {
+      const closeAll = new Array(this[kClients].length)
+      for (let i = 0; i < this[kClients].length; i++) {
+        closeAll[i] = this[kClients][i].close()
       }
+      Promise.all(closeAll)
+        .then(this[kClosedResolve])
     }
+  }
 
-    this[kOnConnect] = (origin, targets) => {
-      pool.emit('connect', origin, [pool, ...targets])
-    }
+  [kOnConnect] = (origin, targets) => {
+    this.emit('connect', origin, [this, ...targets])
+  };
 
-    this[kOnDisconnect] = (origin, targets, err) => {
-      pool.emit('disconnect', origin, [pool, ...targets], err)
-    }
+  [kOnDisconnect] = (origin, targets, err) => {
+    this.emit('disconnect', origin, [this, ...targets], err)
+  };
 
-    this[kOnConnectionError] = (origin, targets, err) => {
-      pool.emit('connectionError', origin, [pool, ...targets], err)
-    }
+  [kOnConnectionError] = (origin, targets, err) => {
+    this.emit('connectionError', origin, [this, ...targets], err)
   }
 
   get [kBusy] () {
@@ -73,11 +74,19 @@ class PoolBase extends DispatcherBase {
   }
 
   get [kConnected] () {
-    return this[kClients].filter(client => client[kConnected]).length
+    let ret = 0
+    for (const { [kConnected]: connected } of this[kClients]) {
+      ret += connected
+    }
+    return ret
   }
 
   get [kFree] () {
-    return this[kClients].filter(client => client[kConnected] && !client[kNeedDrain]).length
+    let ret = 0
+    for (const { [kConnected]: connected, [kNeedDrain]: needDrain } of this[kClients]) {
+      ret += connected && !needDrain
+    }
+    return ret
   }
 
   get [kPending] () {
@@ -108,17 +117,21 @@ class PoolBase extends DispatcherBase {
     return new PoolStats(this)
   }
 
-  async [kClose] () {
+  [kClose] () {
     if (this[kQueue].isEmpty()) {
-      await Promise.all(this[kClients].map(c => c.close()))
+      const closeAll = new Array(this[kClients].length)
+      for (let i = 0; i < this[kClients].length; i++) {
+        closeAll[i] = this[kClients][i].close()
+      }
+      return Promise.all(closeAll)
     } else {
-      await new Promise((resolve) => {
+      return new Promise((resolve) => {
         this[kClosedResolve] = resolve
       })
     }
   }
 
-  async [kDestroy] (err) {
+  [kDestroy] (err) {
     while (true) {
       const item = this[kQueue].shift()
       if (!item) {
@@ -127,7 +140,11 @@ class PoolBase extends DispatcherBase {
       item.handler.onError(err)
     }
 
-    await Promise.all(this[kClients].map(c => c.destroy(err)))
+    const destroyAll = new Array(this[kClients].length)
+    for (let i = 0; i < this[kClients].length; i++) {
+      destroyAll[i] = this[kClients][i].destroy(err)
+    }
+    return Promise.all(destroyAll)
   }
 
   [kDispatch] (opts, handler) {
@@ -147,7 +164,7 @@ class PoolBase extends DispatcherBase {
 
   [kAddClient] (client) {
     client
-      .on('drain', this[kOnDrain])
+      .on('drain', this[kOnDrain].bind(this, client))
       .on('connect', this[kOnConnect])
       .on('disconnect', this[kOnDisconnect])
       .on('connectionError', this[kOnConnectionError])
@@ -157,7 +174,7 @@ class PoolBase extends DispatcherBase {
     if (this[kNeedDrain]) {
       queueMicrotask(() => {
         if (this[kNeedDrain]) {
-          this[kOnDrain](client[kUrl], [this, client])
+          this[kOnDrain](client, client[kUrl], [client, this])
         }
       })
     }

package/lib/dispatcher/pool.js

@@ -51,8 +51,6 @@ class Pool extends PoolBase {
       throw new InvalidArgumentError('connect must be a function or an object')
     }
 
-    super()
-
     if (typeof connect !== 'function') {
       connect = buildConnector({
         ...tls,
@@ -65,6 +63,8 @@ class Pool extends PoolBase {
       })
     }
 
+    super()
+
     this[kConnections] = connections || null
     this[kUrl] = util.parseOrigin(origin)
     this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl }

package/lib/dispatcher/proxy-agent.js

@@ -37,11 +37,12 @@ class Http1ProxyWrapper extends DispatcherBase {
   #client
 
   constructor (proxyUrl, { headers = {}, connect, factory }) {
-    super()
     if (!proxyUrl) {
       throw new InvalidArgumentError('Proxy URL is mandatory')
     }
 
+    super()
+
     this[kProxyHeaders] = headers
     if (factory) {
       this.#client = factory(proxyUrl, { connect })
@@ -80,11 +81,11 @@ class Http1ProxyWrapper extends DispatcherBase {
     return this.#client[kDispatch](opts, handler)
   }
 
-  async [kClose] () {
+  [kClose] () {
     return this.#client.close()
   }
 
-  async [kDestroy] (err) {
+  [kDestroy] (err) {
     return this.#client.destroy(err)
   }
 }
@@ -220,14 +221,18 @@ class ProxyAgent extends DispatcherBase {
     }
   }
 
-  async [kClose] () {
-    await this[kAgent].close()
-    await this[kClient].close()
+  [kClose] () {
+    return Promise.all([
+      this[kAgent].close(),
+      this[kClient].close()
+    ])
   }
 
-  async [kDestroy] () {
-    await this[kAgent].destroy()
-    await this[kClient].destroy()
+  [kDestroy] () {
+    return Promise.all([
+      this[kAgent].destroy(),
+      this[kClient].destroy()
+    ])
   }
 }
 

package/lib/global.js

@@ -26,7 +26,25 @@ function getGlobalDispatcher () {
   return globalThis[globalDispatcher]
 }
 
+// These are the globals that can be installed by undici.install().
+// Not exported by index.js to avoid use outside of this module.
+const installedExports = /** @type {const} */ (
+  [
+    'fetch',
+    'Headers',
+    'Response',
+    'Request',
+    'FormData',
+    'WebSocket',
+    'CloseEvent',
+    'ErrorEvent',
+    'MessageEvent',
+    'EventSource'
+  ]
+)
+
 module.exports = {
   setGlobalDispatcher,
-  getGlobalDispatcher
+  getGlobalDispatcher,
+  installedExports
 }

package/lib/interceptor/cache.js

@@ -56,6 +56,22 @@ function needsRevalidation (result, cacheControlDirectives) {
   return false
 }
 
+/**
+ * Check if we're within the stale-while-revalidate window for a stale response
+ * @param {import('../../types/cache-interceptor.d.ts').default.GetResult} result
+ * @returns {boolean}
+ */
+function withinStaleWhileRevalidateWindow (result) {
+  const staleWhileRevalidate = result.cacheControlDirectives?.['stale-while-revalidate']
+  if (!staleWhileRevalidate) {
+    return false
+  }
+
+  const now = Date.now()
+  const staleWhileRevalidateExpiry = result.staleAt + (staleWhileRevalidate * 1000)
+  return now <= staleWhileRevalidateExpiry
+}
+
 /**
  * @param {DispatchFn} dispatch
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheHandlerOptions} globalOpts
@@ -231,6 +247,51 @@ function handleResult (
       return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler))
     }
 
+    // RFC 5861: If we're within stale-while-revalidate window, serve stale immediately
+    // and revalidate in background
+    if (withinStaleWhileRevalidateWindow(result)) {
+      // Serve stale response immediately
+      sendCachedValue(handler, opts, result, age, null, true)
+
+      // Start background revalidation (fire-and-forget)
+      queueMicrotask(() => {
+        let headers = {
+          ...opts.headers,
+          'if-modified-since': new Date(result.cachedAt).toUTCString()
+        }
+
+        if (result.etag) {
+          headers['if-none-match'] = result.etag
+        }
+
+        if (result.vary) {
+          headers = {
+            ...headers,
+            ...result.vary
+          }
+        }
+
+        // Background revalidation - update cache if we get new data
+        dispatch(
+          {
+            ...opts,
+            headers
+          },
+          new CacheHandler(globalOpts, cacheKey, {
+            // Silent handler that just updates the cache
+            onRequestStart () {},
+            onRequestUpgrade () {},
+            onResponseStart () {},
+            onResponseData () {},
+            onResponseEnd () {},
+            onResponseError () {}
+          })
+        )
+      })
+
+      return true
+    }
+
     let withinStaleIfErrorThreshold = false
     const staleIfErrorExpiry = result.cacheControlDirectives['stale-if-error'] ?? reqCacheControl?.['stale-if-error']
     if (staleIfErrorExpiry) {

package/lib/mock/mock-agent.js

@@ -29,16 +29,16 @@ const PendingInterceptorsFormatter = require('./pending-interceptors-formatter')
 const { MockCallHistory } = require('./mock-call-history')
 
 class MockAgent extends Dispatcher {
-  constructor (opts) {
+  constructor (opts = {}) {
     super(opts)
 
     const mockOptions = buildAndValidateMockOptions(opts)
 
     this[kNetConnect] = true
     this[kIsMockActive] = true
-    this[kMockAgentIsCallHistoryEnabled] = mockOptions?.enableCallHistory ?? false
-    this[kMockAgentAcceptsNonStandardSearchParameters] = mockOptions?.acceptNonStandardSearchParameters ?? false
-    this[kIgnoreTrailingSlash] = mockOptions?.ignoreTrailingSlash ?? false
+    this[kMockAgentIsCallHistoryEnabled] = mockOptions.enableCallHistory ?? false
+    this[kMockAgentAcceptsNonStandardSearchParameters] = mockOptions.acceptNonStandardSearchParameters ?? false
+    this[kIgnoreTrailingSlash] = mockOptions.ignoreTrailingSlash ?? false
 
     // Instantiate Agent and encapsulate
     if (opts?.agent && typeof opts.agent.dispatch !== 'function') {

package/lib/mock/mock-errors.js

@@ -2,6 +2,8 @@
 
 const { UndiciError } = require('../core/errors')
 
+const kMockNotMatchedError = Symbol.for('undici.error.UND_MOCK_ERR_MOCK_NOT_MATCHED')
+
 /**
  * The request does not match any registered mock dispatches.
  */
@@ -12,6 +14,14 @@ class MockNotMatchedError extends UndiciError {
     this.message = message || 'The request does not match any registered mock dispatches'
     this.code = 'UND_MOCK_ERR_MOCK_NOT_MATCHED'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kMockNotMatchedError] === true
+  }
+
+  get [kMockNotMatchedError] () {
+    return true
+  }
 }
 
 module.exports = {

package/lib/mock/mock-utils.js

@@ -367,7 +367,7 @@ function buildMockDispatch () {
       try {
         mockDispatch.call(this, opts, handler)
       } catch (error) {
-        if (error instanceof MockNotMatchedError) {
+        if (error.code === 'UND_MOCK_ERR_MOCK_NOT_MATCHED') {
           const netConnect = agent[kGetNetConnect]()
           if (netConnect === false) {
             throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`)
@@ -398,19 +398,21 @@ function checkNetConnect (netConnect, origin) {
 }
 
 function buildAndValidateMockOptions (opts) {
-  if (opts) {
-    const { agent, ...mockOptions } = opts
+  const { agent, ...mockOptions } = opts
 
-    if ('enableCallHistory' in mockOptions && typeof mockOptions.enableCallHistory !== 'boolean') {
-      throw new InvalidArgumentError('options.enableCallHistory must to be a boolean')
-    }
+  if ('enableCallHistory' in mockOptions && typeof mockOptions.enableCallHistory !== 'boolean') {
+    throw new InvalidArgumentError('options.enableCallHistory must to be a boolean')
+  }
 
-    if ('acceptNonStandardSearchParameters' in mockOptions && typeof mockOptions.acceptNonStandardSearchParameters !== 'boolean') {
-      throw new InvalidArgumentError('options.acceptNonStandardSearchParameters must to be a boolean')
-    }
+  if ('acceptNonStandardSearchParameters' in mockOptions && typeof mockOptions.acceptNonStandardSearchParameters !== 'boolean') {
+    throw new InvalidArgumentError('options.acceptNonStandardSearchParameters must to be a boolean')
+  }
 
-    return mockOptions
+  if ('ignoreTrailingSlash' in mockOptions && typeof mockOptions.ignoreTrailingSlash !== 'boolean') {
+    throw new InvalidArgumentError('options.ignoreTrailingSlash must to be a boolean')
   }
+
+  return mockOptions
 }
 
 module.exports = {