@relative-ci/core 5.3.1 → 5.3.2

package/lib/esm/__/undici/lib/dispatcher/client.js

@@ -0,0 +1,643 @@
+import require$$0$1 from 'node:assert';
+import require$$0 from 'node:net';
+import require$$2 from 'node:http';
+import { __require as requireUtil } from '../core/util.js';
+import { __require as requireDiagnostics } from '../core/diagnostics.js';
+import { __require as requireRequest } from '../core/request.js';
+import { __require as requireDispatcherBase } from './dispatcher-base.js';
+import { __require as requireErrors } from '../core/errors.js';
+import { __require as requireConnect } from '../core/connect.js';
+import { __require as requireSymbols } from '../core/symbols.js';
+import { __require as requireClientH1 } from './client-h1.js';
+import { __require as requireClientH2 } from './client-h2.js';
+import { __require as requireRedirectInterceptor } from '../interceptor/redirect-interceptor.js';
+
+var client;
+var hasRequiredClient;
+
+function requireClient () {
+	if (hasRequiredClient) return client;
+	hasRequiredClient = 1;
+
+	const assert = require$$0$1;
+	const net = require$$0;
+	const http = require$$2;
+	const util = requireUtil();
+	const { channels } = requireDiagnostics();
+	const Request = requireRequest();
+	const DispatcherBase = requireDispatcherBase();
+	const {
+	  InvalidArgumentError,
+	  InformationalError,
+	  ClientDestroyedError
+	} = requireErrors();
+	const buildConnector = requireConnect();
+	const {
+	  kUrl,
+	  kServerName,
+	  kClient,
+	  kBusy,
+	  kConnect,
+	  kResuming,
+	  kRunning,
+	  kPending,
+	  kSize,
+	  kQueue,
+	  kConnected,
+	  kConnecting,
+	  kNeedDrain,
+	  kKeepAliveDefaultTimeout,
+	  kHostHeader,
+	  kPendingIdx,
+	  kRunningIdx,
+	  kError,
+	  kPipelining,
+	  kKeepAliveTimeoutValue,
+	  kMaxHeadersSize,
+	  kKeepAliveMaxTimeout,
+	  kKeepAliveTimeoutThreshold,
+	  kHeadersTimeout,
+	  kBodyTimeout,
+	  kStrictContentLength,
+	  kConnector,
+	  kMaxRedirections,
+	  kMaxRequests,
+	  kCounter,
+	  kClose,
+	  kDestroy,
+	  kDispatch,
+	  kInterceptors,
+	  kLocalAddress,
+	  kMaxResponseSize,
+	  kOnError,
+	  kHTTPContext,
+	  kMaxConcurrentStreams,
+	  kResume
+	} = requireSymbols();
+	const connectH1 = requireClientH1();
+	const connectH2 = requireClientH2();
+	let deprecatedInterceptorWarned = false;
+
+	const kClosedResolve = Symbol('kClosedResolve');
+
+	const noop = () => {};
+
+	function getPipelining (client) {
+	  return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1
+	}
+
+	/**
+	 * @type {import('../../types/client.js').default}
+	 */
+	class Client extends DispatcherBase {
+	  /**
+	   *
+	   * @param {string|URL} url
+	   * @param {import('../../types/client.js').Client.Options} options
+	   */
+	  constructor (url, {
+	    interceptors,
+	    maxHeaderSize,
+	    headersTimeout,
+	    socketTimeout,
+	    requestTimeout,
+	    connectTimeout,
+	    bodyTimeout,
+	    idleTimeout,
+	    keepAlive,
+	    keepAliveTimeout,
+	    maxKeepAliveTimeout,
+	    keepAliveMaxTimeout,
+	    keepAliveTimeoutThreshold,
+	    socketPath,
+	    pipelining,
+	    tls,
+	    strictContentLength,
+	    maxCachedSessions,
+	    maxRedirections,
+	    connect,
+	    maxRequestsPerClient,
+	    localAddress,
+	    maxResponseSize,
+	    autoSelectFamily,
+	    autoSelectFamilyAttemptTimeout,
+	    // h2
+	    maxConcurrentStreams,
+	    allowH2,
+	    webSocket
+	  } = {}) {
+	    super({ webSocket });
+
+	    if (keepAlive !== undefined) {
+	      throw new InvalidArgumentError('unsupported keepAlive, use pipelining=0 instead')
+	    }
+
+	    if (socketTimeout !== undefined) {
+	      throw new InvalidArgumentError('unsupported socketTimeout, use headersTimeout & bodyTimeout instead')
+	    }
+
+	    if (requestTimeout !== undefined) {
+	      throw new InvalidArgumentError('unsupported requestTimeout, use headersTimeout & bodyTimeout instead')
+	    }
+
+	    if (idleTimeout !== undefined) {
+	      throw new InvalidArgumentError('unsupported idleTimeout, use keepAliveTimeout instead')
+	    }
+
+	    if (maxKeepAliveTimeout !== undefined) {
+	      throw new InvalidArgumentError('unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead')
+	    }
+
+	    if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) {
+	      throw new InvalidArgumentError('invalid maxHeaderSize')
+	    }
+
+	    if (socketPath != null && typeof socketPath !== 'string') {
+	      throw new InvalidArgumentError('invalid socketPath')
+	    }
+
+	    if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) {
+	      throw new InvalidArgumentError('invalid connectTimeout')
+	    }
+
+	    if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) {
+	      throw new InvalidArgumentError('invalid keepAliveTimeout')
+	    }
+
+	    if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) {
+	      throw new InvalidArgumentError('invalid keepAliveMaxTimeout')
+	    }
+
+	    if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) {
+	      throw new InvalidArgumentError('invalid keepAliveTimeoutThreshold')
+	    }
+
+	    if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) {
+	      throw new InvalidArgumentError('headersTimeout must be a positive integer or zero')
+	    }
+
+	    if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) {
+	      throw new InvalidArgumentError('bodyTimeout must be a positive integer or zero')
+	    }
+
+	    if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
+	      throw new InvalidArgumentError('connect must be a function or an object')
+	    }
+
+	    if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
+	      throw new InvalidArgumentError('maxRedirections must be a positive number')
+	    }
+
+	    if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
+	      throw new InvalidArgumentError('maxRequestsPerClient must be a positive number')
+	    }
+
+	    if (localAddress != null && (typeof localAddress !== 'string' || net.isIP(localAddress) === 0)) {
+	      throw new InvalidArgumentError('localAddress must be valid string IP address')
+	    }
+
+	    if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) {
+	      throw new InvalidArgumentError('maxResponseSize must be a positive number')
+	    }
+
+	    if (
+	      autoSelectFamilyAttemptTimeout != null &&
+	      (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)
+	    ) {
+	      throw new InvalidArgumentError('autoSelectFamilyAttemptTimeout must be a positive number')
+	    }
+
+	    // h2
+	    if (allowH2 != null && typeof allowH2 !== 'boolean') {
+	      throw new InvalidArgumentError('allowH2 must be a valid boolean value')
+	    }
+
+	    if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== 'number' || maxConcurrentStreams < 1)) {
+	      throw new InvalidArgumentError('maxConcurrentStreams must be a positive integer, greater than 0')
+	    }
+
+	    if (typeof connect !== 'function') {
+	      connect = buildConnector({
+	        ...tls,
+	        maxCachedSessions,
+	        allowH2,
+	        socketPath,
+	        timeout: connectTimeout,
+	        ...(autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
+	        ...connect
+	      });
+	    }
+
+	    if (interceptors?.Client && Array.isArray(interceptors.Client)) {
+	      this[kInterceptors] = interceptors.Client;
+	      if (!deprecatedInterceptorWarned) {
+	        deprecatedInterceptorWarned = true;
+	        process.emitWarning('Client.Options#interceptor is deprecated. Use Dispatcher#compose instead.', {
+	          code: 'UNDICI-CLIENT-INTERCEPTOR-DEPRECATED'
+	        });
+	      }
+	    } else {
+	      this[kInterceptors] = [createRedirectInterceptor({ maxRedirections })];
+	    }
+
+	    this[kUrl] = util.parseOrigin(url);
+	    this[kConnector] = connect;
+	    this[kPipelining] = pipelining != null ? pipelining : 1;
+	    this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize;
+	    this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout;
+	    this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 600e3 : keepAliveMaxTimeout;
+	    this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 2e3 : keepAliveTimeoutThreshold;
+	    this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout];
+	    this[kServerName] = null;
+	    this[kLocalAddress] = localAddress != null ? localAddress : null;
+	    this[kResuming] = 0; // 0, idle, 1, scheduled, 2 resuming
+	    this[kNeedDrain] = 0; // 0, idle, 1, scheduled, 2 resuming
+	    this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ''}\r\n`;
+	    this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 300e3;
+	    this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 300e3;
+	    this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength;
+	    this[kMaxRedirections] = maxRedirections;
+	    this[kMaxRequests] = maxRequestsPerClient;
+	    this[kClosedResolve] = null;
+	    this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1;
+	    this[kMaxConcurrentStreams] = maxConcurrentStreams != null ? maxConcurrentStreams : 100; // Max peerConcurrentStreams for a Node h2 server
+	    this[kHTTPContext] = null;
+
+	    // kQueue is built up of 3 sections separated by
+	    // the kRunningIdx and kPendingIdx indices.
+	    // |   complete   |   running   |   pending   |
+	    //                ^ kRunningIdx ^ kPendingIdx ^ kQueue.length
+	    // kRunningIdx points to the first running element.
+	    // kPendingIdx points to the first pending element.
+	    // This implements a fast queue with an amortized
+	    // time of O(1).
+
+	    this[kQueue] = [];
+	    this[kRunningIdx] = 0;
+	    this[kPendingIdx] = 0;
+
+	    this[kResume] = (sync) => resume(this, sync);
+	    this[kOnError] = (err) => onError(this, err);
+	  }
+
+	  get pipelining () {
+	    return this[kPipelining]
+	  }
+
+	  set pipelining (value) {
+	    this[kPipelining] = value;
+	    this[kResume](true);
+	  }
+
+	  get [kPending] () {
+	    return this[kQueue].length - this[kPendingIdx]
+	  }
+
+	  get [kRunning] () {
+	    return this[kPendingIdx] - this[kRunningIdx]
+	  }
+
+	  get [kSize] () {
+	    return this[kQueue].length - this[kRunningIdx]
+	  }
+
+	  get [kConnected] () {
+	    return !!this[kHTTPContext] && !this[kConnecting] && !this[kHTTPContext].destroyed
+	  }
+
+	  get [kBusy] () {
+	    return Boolean(
+	      this[kHTTPContext]?.busy(null) ||
+	      (this[kSize] >= (getPipelining(this) || 1)) ||
+	      this[kPending] > 0
+	    )
+	  }
+
+	  /* istanbul ignore: only used for test */
+	  [kConnect] (cb) {
+	    connect(this);
+	    this.once('connect', cb);
+	  }
+
+	  [kDispatch] (opts, handler) {
+	    const origin = opts.origin || this[kUrl].origin;
+	    const request = new Request(origin, opts, handler);
+
+	    this[kQueue].push(request);
+	    if (this[kResuming]) ; else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) {
+	      // Wait a tick in case stream/iterator is ended in the same tick.
+	      this[kResuming] = 1;
+	      queueMicrotask(() => resume(this));
+	    } else {
+	      this[kResume](true);
+	    }
+
+	    if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) {
+	      this[kNeedDrain] = 2;
+	    }
+
+	    return this[kNeedDrain] < 2
+	  }
+
+	  async [kClose] () {
+	    // TODO: for H2 we need to gracefully flush the remaining enqueued
+	    // request and close each stream.
+	    return new Promise((resolve) => {
+	      if (this[kSize]) {
+	        this[kClosedResolve] = resolve;
+	      } else {
+	        resolve(null);
+	      }
+	    })
+	  }
+
+	  async [kDestroy] (err) {
+	    return new Promise((resolve) => {
+	      const requests = this[kQueue].splice(this[kPendingIdx]);
+	      for (let i = 0; i < requests.length; i++) {
+	        const request = requests[i];
+	        util.errorRequest(this, request, err);
+	      }
+
+	      const callback = () => {
+	        if (this[kClosedResolve]) {
+	          // TODO (fix): Should we error here with ClientDestroyedError?
+	          this[kClosedResolve]();
+	          this[kClosedResolve] = null;
+	        }
+	        resolve(null);
+	      };
+
+	      if (this[kHTTPContext]) {
+	        this[kHTTPContext].destroy(err, callback);
+	        this[kHTTPContext] = null;
+	      } else {
+	        queueMicrotask(callback);
+	      }
+
+	      this[kResume]();
+	    })
+	  }
+	}
+
+	const createRedirectInterceptor = requireRedirectInterceptor();
+
+	function onError (client, err) {
+	  if (
+	    client[kRunning] === 0 &&
+	    err.code !== 'UND_ERR_INFO' &&
+	    err.code !== 'UND_ERR_SOCKET'
+	  ) {
+	    // Error is not caused by running request and not a recoverable
+	    // socket error.
+
+	    assert(client[kPendingIdx] === client[kRunningIdx]);
+
+	    const requests = client[kQueue].splice(client[kRunningIdx]);
+
+	    for (let i = 0; i < requests.length; i++) {
+	      const request = requests[i];
+	      util.errorRequest(client, request, err);
+	    }
+	    assert(client[kSize] === 0);
+	  }
+	}
+
+	/**
+	 * @param {Client} client
+	 * @returns
+	 */
+	async function connect (client) {
+	  assert(!client[kConnecting]);
+	  assert(!client[kHTTPContext]);
+
+	  let { host, hostname, protocol, port } = client[kUrl];
+
+	  // Resolve ipv6
+	  if (hostname[0] === '[') {
+	    const idx = hostname.indexOf(']');
+
+	    assert(idx !== -1);
+	    const ip = hostname.substring(1, idx);
+
+	    assert(net.isIP(ip));
+	    hostname = ip;
+	  }
+
+	  client[kConnecting] = true;
+
+	  if (channels.beforeConnect.hasSubscribers) {
+	    channels.beforeConnect.publish({
+	      connectParams: {
+	        host,
+	        hostname,
+	        protocol,
+	        port,
+	        version: client[kHTTPContext]?.version,
+	        servername: client[kServerName],
+	        localAddress: client[kLocalAddress]
+	      },
+	      connector: client[kConnector]
+	    });
+	  }
+
+	  try {
+	    const socket = await new Promise((resolve, reject) => {
+	      client[kConnector]({
+	        host,
+	        hostname,
+	        protocol,
+	        port,
+	        servername: client[kServerName],
+	        localAddress: client[kLocalAddress]
+	      }, (err, socket) => {
+	        if (err) {
+	          reject(err);
+	        } else {
+	          resolve(socket);
+	        }
+	      });
+	    });
+
+	    if (client.destroyed) {
+	      util.destroy(socket.on('error', noop), new ClientDestroyedError());
+	      return
+	    }
+
+	    assert(socket);
+
+	    try {
+	      client[kHTTPContext] = socket.alpnProtocol === 'h2'
+	        ? await connectH2(client, socket)
+	        : await connectH1(client, socket);
+	    } catch (err) {
+	      socket.destroy().on('error', noop);
+	      throw err
+	    }
+
+	    client[kConnecting] = false;
+
+	    socket[kCounter] = 0;
+	    socket[kMaxRequests] = client[kMaxRequests];
+	    socket[kClient] = client;
+	    socket[kError] = null;
+
+	    if (channels.connected.hasSubscribers) {
+	      channels.connected.publish({
+	        connectParams: {
+	          host,
+	          hostname,
+	          protocol,
+	          port,
+	          version: client[kHTTPContext]?.version,
+	          servername: client[kServerName],
+	          localAddress: client[kLocalAddress]
+	        },
+	        connector: client[kConnector],
+	        socket
+	      });
+	    }
+	    client.emit('connect', client[kUrl], [client]);
+	  } catch (err) {
+	    if (client.destroyed) {
+	      return
+	    }
+
+	    client[kConnecting] = false;
+
+	    if (channels.connectError.hasSubscribers) {
+	      channels.connectError.publish({
+	        connectParams: {
+	          host,
+	          hostname,
+	          protocol,
+	          port,
+	          version: client[kHTTPContext]?.version,
+	          servername: client[kServerName],
+	          localAddress: client[kLocalAddress]
+	        },
+	        connector: client[kConnector],
+	        error: err
+	      });
+	    }
+
+	    if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
+	      assert(client[kRunning] === 0);
+	      while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
+	        const request = client[kQueue][client[kPendingIdx]++];
+	        util.errorRequest(client, request, err);
+	      }
+	    } else {
+	      onError(client, err);
+	    }
+
+	    client.emit('connectionError', client[kUrl], [client], err);
+	  }
+
+	  client[kResume]();
+	}
+
+	function emitDrain (client) {
+	  client[kNeedDrain] = 0;
+	  client.emit('drain', client[kUrl], [client]);
+	}
+
+	function resume (client, sync) {
+	  if (client[kResuming] === 2) {
+	    return
+	  }
+
+	  client[kResuming] = 2;
+
+	  _resume(client, sync);
+	  client[kResuming] = 0;
+
+	  if (client[kRunningIdx] > 256) {
+	    client[kQueue].splice(0, client[kRunningIdx]);
+	    client[kPendingIdx] -= client[kRunningIdx];
+	    client[kRunningIdx] = 0;
+	  }
+	}
+
+	function _resume (client, sync) {
+	  while (true) {
+	    if (client.destroyed) {
+	      assert(client[kPending] === 0);
+	      return
+	    }
+
+	    if (client[kClosedResolve] && !client[kSize]) {
+	      client[kClosedResolve]();
+	      client[kClosedResolve] = null;
+	      return
+	    }
+
+	    if (client[kHTTPContext]) {
+	      client[kHTTPContext].resume();
+	    }
+
+	    if (client[kBusy]) {
+	      client[kNeedDrain] = 2;
+	    } else if (client[kNeedDrain] === 2) {
+	      if (sync) {
+	        client[kNeedDrain] = 1;
+	        queueMicrotask(() => emitDrain(client));
+	      } else {
+	        emitDrain(client);
+	      }
+	      continue
+	    }
+
+	    if (client[kPending] === 0) {
+	      return
+	    }
+
+	    if (client[kRunning] >= (getPipelining(client) || 1)) {
+	      return
+	    }
+
+	    const request = client[kQueue][client[kPendingIdx]];
+
+	    if (client[kUrl].protocol === 'https:' && client[kServerName] !== request.servername) {
+	      if (client[kRunning] > 0) {
+	        return
+	      }
+
+	      client[kServerName] = request.servername;
+	      client[kHTTPContext]?.destroy(new InformationalError('servername changed'), () => {
+	        client[kHTTPContext] = null;
+	        resume(client);
+	      });
+	    }
+
+	    if (client[kConnecting]) {
+	      return
+	    }
+
+	    if (!client[kHTTPContext]) {
+	      connect(client);
+	      return
+	    }
+
+	    if (client[kHTTPContext].destroyed) {
+	      return
+	    }
+
+	    if (client[kHTTPContext].busy(request)) {
+	      return
+	    }
+
+	    if (!request.aborted && client[kHTTPContext].write(request)) {
+	      client[kPendingIdx]++;
+	    } else {
+	      client[kQueue].splice(client[kPendingIdx], 1);
+	    }
+	  }
+	}
+
+	client = Client;
+	return client;
+}
+
+export { requireClient as __require };
+//# sourceMappingURL=client.js.map