undici-types 7.4.0 → 7.7.0

package/client.d.ts

@@ -70,7 +70,7 @@ export declare namespace Client {
     /** TODO */
     maxRedirections?: number;
     /** TODO */
-    connect?: buildConnector.BuildOptions | buildConnector.connector;
+    connect?: Partial<buildConnector.BuildOptions> | buildConnector.connector;
     /** TODO */
     maxRequestsPerClient?: number;
     /** TODO */

package/dispatcher.d.ts

@@ -12,6 +12,8 @@ type AbortSignal = unknown
 
 export default Dispatcher
 
+export type UndiciHeaders = Record<string, string | string[]> | IncomingHttpHeaders | string[] | Iterable<[string, string | string[] | undefined]> | null
+
 /** Dispatcher is the core API used to dispatch requests. */
 declare class Dispatcher extends EventEmitter {
   /** Dispatches a request. This API is expected to evolve through semver-major versions and is less stable than the preceding higher level APIs. It is primarily intended for library developers who implement higher level APIs on top of this. */
@@ -103,7 +105,7 @@ declare namespace Dispatcher {
     /** Default: `null` */
     body?: string | Buffer | Uint8Array | Readable | null | FormData;
     /** Default: `null` */
-    headers?: Record<string, string | string[]> | IncomingHttpHeaders | string[] | Iterable<[string, string | string[] | undefined]> | null;
+    headers?: UndiciHeaders;
     /** Query string params to be embedded in the request URL. Default: `null` */
     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`. */
@@ -127,7 +129,7 @@ declare namespace Dispatcher {
     origin: string | URL;
     path: string;
     /** Default: `null` */
-    headers?: IncomingHttpHeaders | string[] | null;
+    headers?: UndiciHeaders;
     /** Default: `null` */
     signal?: AbortSignal | EventEmitter | null;
     /** This argument parameter is passed through to `ConnectData` */
@@ -164,7 +166,7 @@ declare namespace Dispatcher {
     /** Default: `'GET'` */
     method?: string;
     /** Default: `null` */
-    headers?: IncomingHttpHeaders | string[] | null;
+    headers?: UndiciHeaders;
     /** A string of comma separated protocols, in descending preference order. Default: `'Websocket'` */
     protocol?: string;
     /** Default: `null` */

package/h2c-client.d.ts

@@ -0,0 +1,75 @@
+import { URL } from 'url'
+import Dispatcher from './dispatcher'
+import buildConnector from './connector'
+
+type H2ClientOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+
+/**
+ * A basic H2C client, mapped on top a single TCP connection. Pipelining is disabled by default.
+ */
+export class H2CClient extends Dispatcher {
+  constructor (url: string | URL, options?: H2CClient.Options)
+  /** Property to get and set the pipelining factor. */
+  pipelining: number
+  /** `true` after `client.close()` has been called. */
+  closed: boolean
+  /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
+  destroyed: boolean
+
+  // Override dispatcher APIs.
+  override connect (
+    options: H2ClientOptions
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
+    options: H2ClientOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void
+}
+
+export declare namespace H2CClient {
+  export interface Options {
+    /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
+    maxHeaderSize?: number;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+    headersTimeout?: number;
+    /** TODO */
+    connectTimeout?: number;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
+    bodyTimeout?: number;
+    /** the timeout, in milliseconds, after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
+    keepAliveTimeout?: number;
+    /** the maximum allowed `idleTimeout`, in milliseconds, when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
+    keepAliveMaxTimeout?: number;
+    /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
+    keepAliveTimeoutThreshold?: number;
+    /** TODO */
+    socketPath?: string;
+    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
+    pipelining?: number;
+    /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
+    strictContentLength?: boolean;
+    /** TODO */
+    maxCachedSessions?: number;
+    /** TODO */
+    maxRedirections?: number;
+    /** TODO */
+    connect?: Omit<Partial<buildConnector.BuildOptions>, 'allowH2'> | buildConnector.connector;
+    /** TODO */
+    maxRequestsPerClient?: number;
+    /** TODO */
+    localAddress?: string;
+    /** Max response body size in bytes, -1 is disabled */
+    maxResponseSize?: number;
+    /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
+    autoSelectFamily?: boolean;
+    /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
+    autoSelectFamilyAttemptTimeout?: number;
+    /**
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @default 100
+    */
+    maxConcurrentStreams?: number
+  }
+}
+
+export default H2CClient

package/index.d.ts

@@ -6,12 +6,14 @@ import { RedirectHandler, DecoratorHandler } from './handlers'
 
 import BalancedPool from './balanced-pool'
 import Client from './client'
+import H2CClient from './h2c-client'
 import buildConnector from './connector'
 import errors from './errors'
 import Agent from './agent'
 import MockClient from './mock-client'
 import MockPool from './mock-pool'
 import MockAgent from './mock-agent'
+import { MockCallHistory, MockCallHistoryLog } from './mock-call-history'
 import mockErrors from './mock-errors'
 import ProxyAgent from './proxy-agent'
 import EnvHttpProxyAgent from './env-http-proxy-agent'
@@ -31,7 +33,7 @@ export * from './content-type'
 export * from './cache'
 export { Interceptable } from './mock-interceptor'
 
-export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, MockClient, MockPool, MockAgent, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent }
+export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, MockClient, MockPool, MockAgent, MockCallHistory, MockCallHistoryLog, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent, H2CClient }
 export default Undici
 
 declare namespace Undici {
@@ -42,6 +44,7 @@ declare namespace Undici {
   const RetryHandler: typeof import ('./retry-handler').default
   const BalancedPool: typeof import('./balanced-pool').default
   const Client: typeof import('./client').default
+  const H2CClient: typeof import('./h2c-client').default
   const buildConnector: typeof import('./connector').default
   const errors: typeof import('./errors').default
   const Agent: typeof import('./agent').default
@@ -55,6 +58,8 @@ declare namespace Undici {
   const MockClient: typeof import('./mock-client').default
   const MockPool: typeof import('./mock-pool').default
   const MockAgent: typeof import('./mock-agent').default
+  const MockCallHistory: typeof import('./mock-call-history').MockCallHistory
+  const MockCallHistoryLog: typeof import('./mock-call-history').MockCallHistoryLog
   const mockErrors: typeof import('./mock-errors').default
   const fetch: typeof import('./fetch').fetch
   const Headers: typeof import('./fetch').Headers

package/mock-agent.d.ts

@@ -2,6 +2,7 @@ import Agent from './agent'
 import Dispatcher from './dispatcher'
 import { Interceptable, MockInterceptor } from './mock-interceptor'
 import MockDispatch = MockInterceptor.MockDispatch
+import { MockCallHistory } from './mock-call-history'
 
 export default MockAgent
 
@@ -31,6 +32,14 @@ declare class MockAgent<TMockAgentOptions extends MockAgent.Options = MockAgent.
   enableNetConnect (host: ((host: string) => boolean)): void
   /** Causes all requests to throw when requests are not matched in a MockAgent intercept. */
   disableNetConnect (): void
+  /** get call history. returns the MockAgent call history or undefined if the option is not enabled. */
+  getCallHistory (): MockCallHistory | undefined
+  /** clear every call history. Any MockCallHistoryLog will be deleted on the MockCallHistory instance */
+  clearCallHistory (): void
+  /** Enable call history. Any subsequence calls will then be registered. */
+  enableCallHistory (): this
+  /** Disable call history. Any subsequence calls will then not be registered. */
+  disableCallHistory (): this
   pendingInterceptors (): PendingInterceptor[]
   assertNoPendingInterceptors (options?: {
     pendingInterceptorsFormatter?: PendingInterceptorsFormatter;
@@ -49,5 +58,8 @@ declare namespace MockAgent {
 
     /** Ignore trailing slashes in the path */
     ignoreTrailingSlash?: boolean;
+
+    /** Enable call history. you can either call MockAgent.enableCallHistory(). default false */
+    enableCallHistory?: boolean
   }
 }

package/mock-call-history.d.ts

@@ -0,0 +1,111 @@
+import Dispatcher from './dispatcher'
+
+declare namespace MockCallHistoryLog {
+  /** request's configuration properties */
+  export type MockCallHistoryLogProperties = 'protocol' | 'host' | 'port' | 'origin' | 'path' | 'hash' | 'fullUrl' | 'method' | 'searchParams' | 'body' | 'headers'
+}
+
+/** a log reflecting request configuration  */
+declare class MockCallHistoryLog {
+  constructor (requestInit: Dispatcher.DispatchOptions)
+  /** protocol used. ie. 'https:' or 'http:' etc... */
+  protocol: string
+  /** request's host. */
+  host: string
+  /** request's port. */
+  port: string
+  /** request's origin. ie. https://localhost:3000. */
+  origin: string
+  /** path. never contains searchParams. */
+  path: string
+  /** request's hash. */
+  hash: string
+  /** the full url requested. */
+  fullUrl: string
+  /** request's method. */
+  method: string
+  /** search params. */
+  searchParams: Record<string, string>
+  /** request's body */
+  body: string | null | undefined
+  /** request's headers */
+  headers: Record<string, string | string[]> | null | undefined
+
+  /** returns an Map of property / value pair */
+  toMap (): Map<MockCallHistoryLog.MockCallHistoryLogProperties, string | Record<string, string | string[]> | null | undefined>
+
+  /** returns a string computed with all key value pair */
+  toString (): string
+}
+
+declare namespace MockCallHistory {
+  export type FilterCallsOperator = 'AND' | 'OR'
+
+  /** modify the filtering behavior */
+  export interface FilterCallsOptions {
+    /** the operator to apply when filtering. 'OR' will adds any MockCallHistoryLog matching any criteria given. 'AND' will adds only MockCallHistoryLog matching every criteria given. (default 'OR')  */
+    operator?: FilterCallsOperator | Lowercase<FilterCallsOperator>
+  }
+  /** a function to be executed for filtering MockCallHistoryLog */
+  export type FilterCallsFunctionCriteria = (log: MockCallHistoryLog) => boolean
+
+  /** parameter to filter MockCallHistoryLog */
+  export type FilterCallsParameter = string | RegExp | undefined | null
+
+  /** an object to execute multiple filtering at once */
+  export interface FilterCallsObjectCriteria extends Record<string, FilterCallsParameter> {
+    /** filter by request protocol. ie https: */
+    protocol?: FilterCallsParameter;
+    /** filter by request host. */
+    host?: FilterCallsParameter;
+    /** filter by request port. */
+    port?: FilterCallsParameter;
+    /** filter by request origin. */
+    origin?: FilterCallsParameter;
+    /** filter by request path. */
+    path?: FilterCallsParameter;
+    /** filter by request hash. */
+    hash?: FilterCallsParameter;
+    /** filter by request fullUrl. */
+    fullUrl?: FilterCallsParameter;
+    /** filter by request method. */
+    method?: FilterCallsParameter;
+  }
+}
+
+/** a call history to track requests configuration */
+declare class MockCallHistory {
+  constructor (name: string)
+  /** returns an array of MockCallHistoryLog. */
+  calls (): Array<MockCallHistoryLog>
+  /** returns the first MockCallHistoryLog */
+  firstCall (): MockCallHistoryLog | undefined
+  /** returns the last MockCallHistoryLog. */
+  lastCall (): MockCallHistoryLog | undefined
+  /** returns the nth MockCallHistoryLog. */
+  nthCall (position: number): MockCallHistoryLog | undefined
+  /** return all MockCallHistoryLog matching any of criteria given. if an object is used with multiple properties, you can change the operator to apply during filtering on options */
+  filterCalls (criteria: MockCallHistory.FilterCallsFunctionCriteria | MockCallHistory.FilterCallsObjectCriteria | RegExp, options?: MockCallHistory.FilterCallsOptions): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given protocol. if a string is given, it is matched with includes */
+  filterCallsByProtocol (protocol: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given host. if a string is given, it is matched with includes */
+  filterCallsByHost (host: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given port. if a string is given, it is matched with includes */
+  filterCallsByPort (port: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given origin. if a string is given, it is matched with includes */
+  filterCallsByOrigin (origin: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given path. if a string is given, it is matched with includes */
+  filterCallsByPath (path: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given hash. if a string is given, it is matched with includes */
+  filterCallsByHash (hash: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given fullUrl. if a string is given, it is matched with includes */
+  filterCallsByFullUrl (fullUrl: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given method. if a string is given, it is matched with includes */
+  filterCallsByMethod (method: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** clear all MockCallHistoryLog on this MockCallHistory. */
+  clear (): void
+  /** use it with for..of loop or spread operator */
+  [Symbol.iterator]: () => Generator<MockCallHistoryLog>
+}
+
+export { MockCallHistoryLog, MockCallHistory }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici-types",
-  "version": "7.4.0",
+  "version": "7.7.0",
   "description": "A stand-alone types package for Undici",
   "homepage": "https://undici.nodejs.org",
   "bugs": {