undici 7.16.0 → 7.17.0

package/types/index.d.ts

@@ -5,6 +5,7 @@ import Pool from './pool'
 import { RedirectHandler, DecoratorHandler } from './handlers'
 
 import BalancedPool from './balanced-pool'
+import RoundRobinPool from './round-robin-pool'
 import Client from './client'
 import H2CClient from './h2c-client'
 import buildConnector from './connector'
@@ -23,6 +24,12 @@ import RetryAgent from './retry-agent'
 import { request, pipeline, stream, connect, upgrade } from './api'
 import interceptors from './interceptors'
 
+import CacheInterceptor from './cache-interceptor'
+declare const cacheStores: {
+  MemoryCacheStore: typeof CacheInterceptor.MemoryCacheStore;
+  SqliteCacheStore: typeof CacheInterceptor.SqliteCacheStore;
+}
+
 export * from './util'
 export * from './cookies'
 export * from './eventsource'
@@ -36,7 +43,7 @@ export { Interceptable } from './mock-interceptor'
 
 declare function globalThisInstall (): void
 
-export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, MockClient, MockPool, MockAgent, SnapshotAgent, MockCallHistory, MockCallHistoryLog, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent, H2CClient, globalThisInstall as install }
+export { Dispatcher, BalancedPool, RoundRobinPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, cacheStores, MockClient, MockPool, MockAgent, SnapshotAgent, MockCallHistory, MockCallHistoryLog, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent, H2CClient, globalThisInstall as install }
 export default Undici
 
 declare namespace Undici {
@@ -46,6 +53,7 @@ declare namespace Undici {
   const DecoratorHandler: typeof import ('./handlers').DecoratorHandler
   const RetryHandler: typeof import ('./retry-handler').default
   const BalancedPool: typeof import('./balanced-pool').default
+  const RoundRobinPool: typeof import('./round-robin-pool').default
   const Client: typeof import('./client').default
   const H2CClient: typeof import('./h2c-client').default
   const buildConnector: typeof import('./connector').default

package/types/interceptors.d.ts

@@ -19,14 +19,47 @@ declare namespace Interceptors {
 
   // DNS interceptor
   export type DNSInterceptorRecord = { address: string, ttl: number, family: 4 | 6 }
-  export type DNSInterceptorOriginRecords = { 4: { ips: DNSInterceptorRecord[] } | null, 6: { ips: DNSInterceptorRecord[] } | null }
+  export type DNSInterceptorOriginRecords = { records: { 4: { ips: DNSInterceptorRecord[] } | null, 6: { ips: DNSInterceptorRecord[] } | null } }
+  export type DNSStorage = {
+    size: number
+    get(origin: string): DNSInterceptorOriginRecords | null
+    set(origin: string, records: DNSInterceptorOriginRecords | null, options: { ttl: number }): void
+    delete(origin: string): void
+    full(): boolean
+  }
   export type DNSInterceptorOpts = {
     maxTTL?: number
     maxItems?: number
-    lookup?: (hostname: string, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, addresses: DNSInterceptorRecord[]) => void) => void
+    lookup?: (origin: URL, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, addresses: DNSInterceptorRecord[]) => void) => void
     pick?: (origin: URL, records: DNSInterceptorOriginRecords, affinity: 4 | 6) => DNSInterceptorRecord
     dualStack?: boolean
     affinity?: 4 | 6
+    storage?: DNSStorage
+  }
+
+  // Deduplicate interceptor
+  export type DeduplicateMethods = 'GET' | 'HEAD' | 'OPTIONS' | 'TRACE'
+  export type DeduplicateInterceptorOpts = {
+    /**
+     * The HTTP methods to deduplicate.
+     * Note: Only safe HTTP methods can be deduplicated.
+     * @default ['GET']
+     */
+    methods?: DeduplicateMethods[]
+    /**
+     * Header names that, if present in a request, will cause the request to skip deduplication.
+     * Header name matching is case-insensitive.
+     * @default []
+     */
+    skipHeaderNames?: string[]
+    /**
+     * Header names to exclude from the deduplication key.
+     * Requests with different values for these headers will still be deduplicated together.
+     * Useful for headers like `x-request-id` that vary per request but shouldn't affect deduplication.
+     * Header name matching is case-insensitive.
+     * @default []
+     */
+    excludeHeaderNames?: string[]
   }
 
   export function dump (opts?: DumpInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
@@ -36,4 +69,5 @@ declare namespace Interceptors {
   export function responseError (opts?: ResponseErrorInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function dns (opts?: DNSInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function cache (opts?: CacheInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function deduplicate (opts?: DeduplicateInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
 }

package/types/pool.d.ts

@@ -1,6 +1,6 @@
 import Client from './client'
 import TPoolStats from './pool-stats'
-import { URL } from 'url'
+import { URL } from 'node:url'
 import Dispatcher from './dispatcher'
 
 export default Pool

package/types/readable.d.ts

@@ -1,5 +1,5 @@
-import { Readable } from 'stream'
-import { Blob } from 'buffer'
+import { Readable } from 'node:stream'
+import { Blob } from 'node:buffer'
 
 export default BodyReadable
 

package/types/round-robin-pool.d.ts

@@ -0,0 +1,41 @@
+import Client from './client'
+import TPoolStats from './pool-stats'
+import { URL } from 'node:url'
+import Dispatcher from './dispatcher'
+
+export default RoundRobinPool
+
+type RoundRobinPoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+
+declare class RoundRobinPool extends Dispatcher {
+  constructor (url: string | URL, options?: RoundRobinPool.Options)
+  /** `true` after `pool.close()` has been called. */
+  closed: boolean
+  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
+  destroyed: boolean
+  /** Aggregate stats for a RoundRobinPool. */
+  readonly stats: TPoolStats
+
+  // Override dispatcher APIs.
+  override connect (
+    options: RoundRobinPoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
+    options: RoundRobinPoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void
+}
+
+declare namespace RoundRobinPool {
+  export type RoundRobinPoolStats = TPoolStats
+  export interface Options extends Client.Options {
+    /** Default: `(origin, opts) => new Client(origin, opts)`. */
+    factory?(origin: URL, opts: object): Dispatcher;
+    /** The max number of clients to create. `null` if no limit. Default `null`. */
+    connections?: number | null;
+    /** The amount of time before a client is removed from the pool and closed. `null` if no time limit. Default `null` */
+    clientTtl?: number | null;
+
+    interceptors?: { RoundRobinPool?: readonly Dispatcher.DispatchInterceptor[] } & Client.Options['interceptors']
+  }
+}

package/types/websocket.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 
-import type { Blob } from 'buffer'
-import type { ReadableStream, WritableStream } from 'stream/web'
-import type { MessagePort } from 'worker_threads'
+import type { Blob } from 'node:buffer'
+import type { ReadableStream, WritableStream } from 'node:stream/web'
+import type { MessagePort } from 'node:worker_threads'
 import {
   EventInit,
   EventListenerOptions,
@@ -96,16 +96,16 @@ interface MessageEventInit<T = any> extends EventInit {
   data?: T
   lastEventId?: string
   origin?: string
-  ports?: (typeof MessagePort)[]
-  source?: typeof MessagePort | null
+  ports?: MessagePort[]
+  source?: MessagePort | null
 }
 
 interface MessageEvent<T = any> extends Event {
   readonly data: T
   readonly lastEventId: string
   readonly origin: string
-  readonly ports: ReadonlyArray<typeof MessagePort>
-  readonly source: typeof MessagePort | null
+  readonly ports: readonly MessagePort[]
+  readonly source: MessagePort | null
   initMessageEvent(
     type: string,
     bubbles?: boolean,
@@ -113,8 +113,8 @@ interface MessageEvent<T = any> extends Event {
     data?: any,
     origin?: string,
     lastEventId?: string,
-    source?: typeof MessagePort | null,
-    ports?: (typeof MessagePort)[]
+    source?: MessagePort | null,
+    ports?: MessagePort[]
   ): void;
 }