undici 7.0.0-alpha.2 → 7.0.0-alpha.3

package/types/cache-interceptor.d.ts

@@ -0,0 +1,97 @@
+import { Readable, Writable } from 'node:stream'
+import Dispatcher from './dispatcher'
+
+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[]
+  }
+
+  /**
+   * 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
+
+    createReadStream(req: Dispatcher.RequestOptions): CacheStoreReadable | Promise<CacheStoreReadable | undefined> | undefined
+
+    createWriteStream(req: Dispatcher.RequestOptions, value: Omit<CacheStoreValue, 'rawTrailers'>): CacheStoreWriteable | undefined
+
+    /**
+     * Delete all of the cached responses from a certain origin (host)
+     */
+    deleteByOrigin(origin: string): void | Promise<void>
+  }
+
+  export interface CacheStoreReadable extends Readable {
+    get value(): CacheStoreValue
+  }
+
+  export interface CacheStoreWriteable extends Writable {
+    set rawTrailers(rawTrailers: string[] | undefined)
+  }
+
+  export interface CacheStoreValue {
+    statusCode: number;
+    statusMessage: string;
+    rawHeaders: (Buffer | Buffer[])[];
+    rawTrailers?: string[];
+    /**
+     * Headers defined by the Vary header and their respective values for
+     *  later comparison
+     */
+    vary?: Record<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
+     */
+    maxEntries?: number
+    /**
+     * @default Infinity
+     */
+    maxEntrySize?: number
+    errorCallback?: (err: Error) => void
+  }
+
+  export class MemoryCacheStore implements CacheStore {
+    constructor (opts?: MemoryCacheStoreOpts)
+
+    get isFull (): boolean
+
+    createReadStream (req: Dispatcher.RequestOptions): CacheStoreReadable | undefined
+
+    createWriteStream (req: Dispatcher.RequestOptions, value: CacheStoreValue): CacheStoreWriteable
+
+    deleteByOrigin (origin: string): void
+  }
+}

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

@@ -64,4 +64,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 }
@@ -28,4 +31,5 @@ declare namespace Interceptors {
   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 {