142 lines
4.3 KiB
TypeScript
142 lines
4.3 KiB
TypeScript
// See https://github.com/facebook/jest/issues/2549
|
|
// eslint-disable-next-line node/prefer-global/url
|
|
import {URL} from 'url';
|
|
import {EventEmitter} from 'events';
|
|
import tls = require('tls');
|
|
import http = require('http');
|
|
import https = require('https');
|
|
import http2 = require('http2');
|
|
|
|
// Note: do not convert this to import from.
|
|
import QuickLRU = require('quick-lru');
|
|
|
|
export interface RequestOptions extends Omit<https.RequestOptions, 'session' | 'agent'> {
|
|
tlsSession?: tls.ConnectionOptions['session'];
|
|
h2session?: http2.ClientHttp2Session;
|
|
agent?: Agent | false;
|
|
|
|
// Required because @types/node is missing types
|
|
ALPNProtocols?: string[];
|
|
}
|
|
|
|
export interface AutoRequestOptions extends Omit<RequestOptions, 'agent' | 'h2session'> {
|
|
agent?: {
|
|
http?: http.Agent | false;
|
|
https?: https.Agent | false;
|
|
http2?: Agent | false;
|
|
};
|
|
resolveProtocol?: ResolveProtocolFunction;
|
|
}
|
|
|
|
export interface EntryFunction {
|
|
(): Promise<void>;
|
|
|
|
completed: boolean;
|
|
destroyed: boolean;
|
|
listeners: PromiseListeners;
|
|
}
|
|
|
|
export interface AgentOptions {
|
|
timeout?: number;
|
|
maxSessions?: number;
|
|
maxEmptySessions?: number;
|
|
maxCachedTlsSessions?: number;
|
|
}
|
|
|
|
export interface PromiseListeners {
|
|
resolve: (value: unknown) => void;
|
|
reject: (error: Error) => void;
|
|
}
|
|
|
|
export class Agent extends EventEmitter {
|
|
sessions: Record<string, http2.ClientHttp2Session[]>;
|
|
queue: Record<string, Record<string, EntryFunction>>;
|
|
|
|
timeout: number;
|
|
maxSessions: number;
|
|
maxEmptySessions: number;
|
|
protocol: string;
|
|
settings: http2.Settings;
|
|
|
|
tlsSessionCache: QuickLRU<string, string>;
|
|
|
|
emptySessionCount: number;
|
|
pendingSessionCount: number;
|
|
sessionCount: number;
|
|
|
|
constructor(options?: AgentOptions);
|
|
|
|
static connect(origin: URL, options: http2.SecureClientSessionOptions): tls.TLSSocket;
|
|
|
|
normalizeOptions(options: http2.ClientSessionRequestOptions): string;
|
|
|
|
getSession(origin: string | URL, options?: http2.SecureClientSessionOptions, listeners?: PromiseListeners): Promise<http2.ClientHttp2Session>;
|
|
request(origin: string | URL, options?: http2.SecureClientSessionOptions, headers?: http2.OutgoingHttpHeaders, streamOptions?: http2.ClientSessionRequestOptions): Promise<http2.ClientHttp2Stream>;
|
|
|
|
createConnection(origin: URL, options: http2.SecureClientSessionOptions): Promise<tls.TLSSocket>;
|
|
|
|
closeEmptySessions(count?: number): void;
|
|
destroy(reason?: Error): void;
|
|
}
|
|
|
|
export interface ProxyOptions {
|
|
headers?: http2.OutgoingHttpHeaders;
|
|
raw?: boolean;
|
|
url: URL | string;
|
|
}
|
|
|
|
export namespace proxies {
|
|
class HttpOverHttp2 extends http.Agent {
|
|
constructor(options: http.AgentOptions & {proxyOptions: ProxyOptions});
|
|
}
|
|
|
|
class HttpsOverHttp2 extends https.Agent {
|
|
constructor(options: https.AgentOptions & {proxyOptions: ProxyOptions});
|
|
}
|
|
|
|
class Http2OverHttp2 extends Agent {
|
|
constructor(options: AgentOptions & {proxyOptions: ProxyOptions});
|
|
}
|
|
|
|
class Http2OverHttp extends Agent {
|
|
constructor(options: AgentOptions & {proxyOptions: ProxyOptions});
|
|
}
|
|
|
|
class Http2OverHttps extends Agent {
|
|
constructor(options: AgentOptions & {proxyOptions: ProxyOptions});
|
|
}
|
|
}
|
|
|
|
export type RequestFunction<T, O = RequestOptions> =
|
|
((url: string | URL, options?: O, callback?: (response: http.IncomingMessage) => void) => T) &
|
|
((url: string | URL, callback?: (response: http.IncomingMessage) => void) => T) &
|
|
((options: O, callback?: (response: http.IncomingMessage) => void) => T);
|
|
|
|
export const globalAgent: Agent;
|
|
|
|
export type ResolveProtocolResult = {
|
|
alpnProtocol: string;
|
|
socket?: tls.TLSSocket;
|
|
timeout?: boolean;
|
|
};
|
|
export type ResolveProtocolFunction = (options: AutoRequestOptions) => Promise<ResolveProtocolResult>;
|
|
|
|
type Promisable<T> = T | Promise<T>;
|
|
|
|
export type ResolveProtocolConnectFunction = (options: tls.ConnectionOptions, callback: () => void) => Promisable<tls.TLSSocket>;
|
|
|
|
export const request: RequestFunction<http.ClientRequest>;
|
|
export const get: RequestFunction<http.ClientRequest>;
|
|
export const auto: RequestFunction<Promise<http.ClientRequest>, AutoRequestOptions> & {
|
|
protocolCache: QuickLRU<string, string>;
|
|
resolveProtocol: ResolveProtocolFunction;
|
|
createResolveProtocol: (cache: Map<string, string>, queue: Map<string, Promise<ResolveProtocolResult>>, connect?: ResolveProtocolConnectFunction) => ResolveProtocolFunction;
|
|
};
|
|
|
|
export {
|
|
ClientRequest,
|
|
IncomingMessage
|
|
} from 'http';
|
|
|
|
export * from 'http2';
|