undici 7.0.0-alpha.2 → 7.0.0-alpha.4

package/types/cache-interceptor.d.ts

@@ -0,0 +1,101 @@
+import { Readable, Writable } from 'node:stream'
+
+export default CacheHandler
+
+declare namespace CacheHandler {
+  export type CacheMethods = 'GET' | 'HEAD' | 'OPTIONS' | 'TRACE'
+
+  export interface CacheOptions {
+    store?: CacheStore
+
+    /**
+     * The methods to cache
+     * Note we can only cache safe methods. Unsafe methods (i.e. PUT, POST)
+     *  invalidate the cache for a origin.
+     * @see https://www.rfc-editor.org/rfc/rfc9111.html#name-invalidating-stored-respons
+     * @see https://www.rfc-editor.org/rfc/rfc9110#section-9.2.1
+     */
+    methods?: CacheMethods[]
+  }
+
+  export interface CacheKey {
+    origin: string
+    method: string
+    path: string
+    headers?: Record<string, string | string[]>
+  }
+
+  export interface DeleteByUri {
+    origin: string
+    method: string
+    path: string
+  }
+
+  type GetResult = CachedResponse & { body: null | Readable | Iterable<Buffer> | Buffer | Iterable<string> | string }
+
+  /**
+   * Underlying storage provider for cached responses
+   */
+  export interface CacheStore {
+    /**
+     * Whether or not the cache is full and can not store any more responses
+     */
+    get isFull(): boolean | undefined
+
+    get(key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream(key: CacheKey, value: CachedResponse): Writable | undefined
+
+    delete(key: CacheKey): void | Promise<void>
+  }
+
+  export interface CachedResponse {
+    statusCode: number;
+    statusMessage: string;
+    rawHeaders: Buffer[];
+    /**
+     * Headers defined by the Vary header and their respective values for
+     *  later comparison
+     */
+    vary?: Record<string, string | string[]>
+    /**
+     * Time in millis that this value was cached
+     */
+    cachedAt: number
+    /**
+     * Time in millis that this value is considered stale
+     */
+    staleAt: number
+    /**
+     * Time in millis that this value is to be deleted from the cache. This is
+     *  either the same as staleAt or the `max-stale` caching directive.
+     */
+    deleteAt: number
+  }
+
+  export interface MemoryCacheStoreOpts {
+    /**
+       * @default Infinity
+       */
+    maxCount?: number
+
+    /**
+       * @default Infinity
+       */
+    maxEntrySize?: number
+
+    errorCallback?: (err: Error) => void
+  }
+
+  export class MemoryCacheStore implements CacheStore {
+    constructor (opts?: MemoryCacheStoreOpts)
+
+    get isFull (): boolean | undefined
+
+    get (key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream (key: CacheKey, value: CachedResponse): Writable | undefined
+
+    delete (key: CacheKey): void | Promise<void>
+  }
+}

package/types/cookies.d.ts

@@ -26,3 +26,5 @@ export function getCookies (headers: Headers): Record<string, string>
 export function getSetCookies (headers: Headers): Cookie[]
 
 export function setCookie (headers: Headers, cookie: Cookie): void
+
+export function parseCookie (cookie: string): Cookie | null

package/types/dispatcher.d.ts

@@ -108,7 +108,7 @@ declare namespace Dispatcher {
     query?: Record<string, any>;
     /** Whether the requests can be safely retried or not. If `false` the request won't be sent until all preceding requests in the pipeline have completed. Default: `true` if `method` is `HEAD` or `GET`. */
     idempotent?: boolean;
-    /** Whether the response is expected to take a long time and would end up blocking the pipeline. When this is set to `true` further pipelining will be avoided on the same connection until headers have been received. */
+    /** Whether the response is expected to take a long time and would end up blocking the pipeline. When this is set to `true` further pipelining will be avoided on the same connection until headers have been received. Defaults to `method !== 'HEAD'`. */
     blocking?: boolean;
     /** Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`. Default: `method === 'CONNECT' || null`. */
     upgrade?: boolean | string | null;

package/types/fetch.d.ts

@@ -119,20 +119,21 @@ type RequestDestination =
   | 'xslt'
 
 export interface RequestInit {
-  method?: string
-  keepalive?: boolean
-  headers?: HeadersInit
   body?: BodyInit | null
-  redirect?: RequestRedirect
-  integrity?: string
-  signal?: AbortSignal | null
+  cache?: RequestCache
   credentials?: RequestCredentials
+  dispatcher?: Dispatcher
+  duplex?: RequestDuplex
+  headers?: HeadersInit
+  integrity?: string
+  keepalive?: boolean
+  method?: string
   mode?: RequestMode
+  redirect?: RequestRedirect
   referrer?: string
   referrerPolicy?: ReferrerPolicy
+  signal?: AbortSignal | null
   window?: null
-  dispatcher?: Dispatcher
-  duplex?: RequestDuplex
 }
 
 export type ReferrerPolicy =

package/types/index.d.ts

@@ -40,7 +40,6 @@ declare namespace Undici {
   const RedirectHandler: typeof import ('./handlers').RedirectHandler
   const DecoratorHandler: typeof import ('./handlers').DecoratorHandler
   const RetryHandler: typeof import ('./retry-handler').default
-  const createRedirectInterceptor: typeof import ('./interceptors').default.createRedirectInterceptor
   const BalancedPool: typeof import('./balanced-pool').default
   const Client: typeof import('./client').default
   const buildConnector: typeof import('./connector').default
@@ -64,4 +63,7 @@ declare namespace Undici {
   const FormData: typeof import('./formdata').FormData
   const caches: typeof import('./cache').caches
   const interceptors: typeof import('./interceptors').default
+  const cacheStores: {
+    MemoryCacheStore: typeof import('./cache-interceptor').default.MemoryCacheStore
+  }
 }

package/types/interceptors.d.ts

@@ -1,3 +1,4 @@
+import CacheHandler from './cache-interceptor'
 import Dispatcher from './dispatcher'
 import RetryHandler from './retry-handler'
 import { LookupOptions } from 'node:dns'
@@ -10,6 +11,8 @@ declare namespace Interceptors {
   export type RedirectInterceptorOpts = { maxRedirections?: number }
 
   export type ResponseErrorInterceptorOpts = { throwOnError: boolean }
+  export type CacheInterceptorOpts = CacheHandler.CacheOptions
+
   // DNS interceptor
   export type DNSInterceptorRecord = { address: string, ttl: number, family: 4 | 6 }
   export type DNSInterceptorOriginRecords = { 4: { ips: DNSInterceptorRecord[] } | null, 6: { ips: DNSInterceptorRecord[] } | null }
@@ -22,10 +25,10 @@ declare namespace Interceptors {
     affinity?: 4 | 6
   }
 
-  export function createRedirectInterceptor (opts: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function dump (opts?: DumpInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function retry (opts?: RetryInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function redirect (opts?: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function responseError (opts?: ResponseErrorInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function dns (opts?: DNSInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function cache (opts?: CacheInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
 }

package/types/webidl.d.ts

@@ -84,7 +84,13 @@ interface WebidlUtil {
    */
   Stringify (V: any): string
 
-  MakeTypeAssertion <T extends { prototype: T }>(Prototype: T['prototype']): (arg: any) => arg is T
+  MakeTypeAssertion <I>(I: I): (arg: any) => arg is I
+
+  /**
+   * Mark a value as uncloneable for Node.js.
+   * This is only effective in some newer Node.js versions.
+   */
+  markAsUncloneable (V: any): void
 }
 
 interface WebidlConverters {