global-agent 4.1.2 → 4.1.3

package/src/factories/createGlobalProxyAgent.ts

@@ -1,187 +0,0 @@
-import http from 'http';
-import https from 'https';
-import semverGte from 'semver/functions/gte';
-import {
-  logger,
-  setLogger,
-} from '../Logger';
-import {
-  HttpProxyAgent,
-  HttpsProxyAgent,
-} from '../classes';
-import {
-  UnexpectedStateError,
-} from '../errors';
-import type {
-  ProxyAgentConfigurationInputType,
-  ProxyAgentConfigurationType,
-} from '../types';
-import {
-  bindHttpMethod,
-  isUrlMatchingNoProxy,
-  parseProxyUrl,
-} from '../utilities';
-import {
-  parseBoolean,
-} from '../utilities/parseBoolean';
-import createProxyController from './createProxyController';
-
-const httpGet = http.get;
-const httpRequest = http.request;
-const httpsGet = https.get;
-const httpsRequest = https.request;
-
-const log = logger.child({
-  namespace: 'createGlobalProxyAgent',
-});
-
-const defaultConfigurationInput = {
-  environmentVariableNamespace: undefined,
-  forceGlobalAgent: undefined,
-  socketConnectionTimeout: 60_000,
-};
-
-const createConfiguration = (configurationInput: ProxyAgentConfigurationInputType): ProxyAgentConfigurationType => {
-  // oxlint-disable-next-line node/no-process-env
-  const environment = process.env;
-
-  const defaultConfiguration = {
-    environmentVariableNamespace: typeof environment.GLOBAL_AGENT_ENVIRONMENT_VARIABLE_NAMESPACE === 'string' ? environment.GLOBAL_AGENT_ENVIRONMENT_VARIABLE_NAMESPACE : 'GLOBAL_AGENT_',
-    forceGlobalAgent: typeof environment.GLOBAL_AGENT_FORCE_GLOBAL_AGENT === 'string' ? parseBoolean(environment.GLOBAL_AGENT_FORCE_GLOBAL_AGENT) : true,
-    socketConnectionTimeout: typeof environment.GLOBAL_AGENT_SOCKET_CONNECTION_TIMEOUT === 'string' ? Number.parseInt(environment.GLOBAL_AGENT_SOCKET_CONNECTION_TIMEOUT, 10) : defaultConfigurationInput.socketConnectionTimeout,
-  };
-
-  return {
-    ...defaultConfiguration,
-    ...Object.fromEntries(Object.entries(configurationInput).filter(([, v]) => v !== undefined)),
-  };
-};
-
-export default (configurationInput: ProxyAgentConfigurationInputType = defaultConfigurationInput) => {
-  const configuration = createConfiguration(configurationInput);
-
-  if (configurationInput.logger) {
-    setLogger(configurationInput.logger);
-  }
-
-  const proxyController = createProxyController();
-
-  // oxlint-disable-next-line node/no-process-env
-  proxyController.HTTP_PROXY = process.env[configuration.environmentVariableNamespace + 'HTTP_PROXY'] ?? null;
-
-  // oxlint-disable-next-line node/no-process-env
-  proxyController.HTTPS_PROXY = process.env[configuration.environmentVariableNamespace + 'HTTPS_PROXY'] ?? null;
-
-  // oxlint-disable-next-line node/no-process-env
-  proxyController.NO_PROXY = process.env[configuration.environmentVariableNamespace + 'NO_PROXY'] ?? null;
-
-  log.info({
-    configuration,
-    state: proxyController,
-  }, 'global agent has been initialized');
-
-  const mustUrlUseProxy = (getProxy: () => string | null) => {
-    return (url: string): boolean => {
-      if (!getProxy()) {
-        return false;
-      }
-
-      if (!proxyController.NO_PROXY) {
-        return true;
-      }
-
-      return !isUrlMatchingNoProxy(url, proxyController.NO_PROXY);
-    };
-  };
-
-  const getUrlProxy = (getProxy: () => string | null) => {
-    return () => {
-      const proxy = getProxy();
-
-      if (!proxy) {
-        throw new UnexpectedStateError('HTTP(S) proxy must be configured.');
-      }
-
-      return parseProxyUrl(proxy);
-    };
-  };
-
-  const getHttpProxy = () => {
-    return proxyController.HTTP_PROXY;
-  };
-
-  const BoundHttpProxyAgent = class extends HttpProxyAgent {
-    public constructor () {
-      super(
-        () => {
-          return Boolean(getHttpProxy());
-        },
-        mustUrlUseProxy(getHttpProxy),
-        getUrlProxy(getHttpProxy),
-        http.globalAgent,
-        configuration.socketConnectionTimeout,
-        configuration.ca,
-      );
-    }
-  };
-
-  const httpAgent = new BoundHttpProxyAgent();
-
-  const getHttpsProxy = () => {
-    return proxyController.HTTPS_PROXY ?? proxyController.HTTP_PROXY;
-  };
-
-  const BoundHttpsProxyAgent = class extends HttpsProxyAgent {
-    public constructor () {
-      super(
-        () => {
-          return Boolean(getHttpsProxy());
-        },
-        mustUrlUseProxy(getHttpsProxy),
-        getUrlProxy(getHttpsProxy),
-        https.globalAgent,
-        configuration.socketConnectionTimeout,
-        configuration.ca,
-      );
-    }
-  };
-
-  const httpsAgent = new BoundHttpsProxyAgent();
-
-  // Overriding globalAgent was added in v11.7.
-  // @see https://nodejs.org/uk/blog/release/v11.7.0/
-  if (semverGte(process.version, 'v11.7.0')) {
-    // @see https://github.com/facebook/flow/issues/7670
-    // @ts-expect-error Node.js version compatibility
-    http.globalAgent = httpAgent;
-
-    // @ts-expect-error Node.js version compatibility
-    https.globalAgent = httpsAgent;
-  }
-
-  // The reason this logic is used in addition to overriding http(s).globalAgent
-  // is because there is no guarantee that we set http(s).globalAgent variable
-  // before an instance of http(s).Agent has been already constructed by someone,
-  // e.g. Stripe SDK creates instances of http(s).Agent at the top-level.
-  // @see https://github.com/gajus/global-agent/pull/13
-  //
-  // We still want to override http(s).globalAgent when possible to enable logic
-  // in `bindHttpMethod`.
-  if (semverGte(process.version, 'v10.0.0')) {
-    // @ts-expect-error seems like we are using wrong type for httpAgent
-    http.get = bindHttpMethod(httpGet, httpAgent, configuration.forceGlobalAgent);
-
-    // @ts-expect-error seems like we are using wrong type for httpAgent
-    http.request = bindHttpMethod(httpRequest, httpAgent, configuration.forceGlobalAgent);
-
-    // @ts-expect-error seems like we are using wrong type for httpAgent
-    https.get = bindHttpMethod(httpsGet, httpsAgent, configuration.forceGlobalAgent);
-
-    // @ts-expect-error seems like we are using wrong type for httpAgent
-    https.request = bindHttpMethod(httpsRequest, httpsAgent, configuration.forceGlobalAgent);
-  } else {
-    log.warn('attempt to initialize global-agent in unsupported Node.js version was ignored');
-  }
-
-  return proxyController;
-};

package/src/factories/createProxyController.test.ts

@@ -1,38 +0,0 @@
-import {
-  expect,
-  test,
-} from 'vitest';
-import createProxyController from './createProxyController';
-
-test('sets HTTP_PROXY', () => {
-  const globalAgentGlobal = createProxyController();
-
-  globalAgentGlobal.HTTP_PROXY = 'http://127.0.0.1';
-
-  expect(globalAgentGlobal.HTTP_PROXY).toBe('http://127.0.0.1');
-});
-
-test('sets HTTPS_PROXY', () => {
-  const globalAgentGlobal = createProxyController();
-
-  globalAgentGlobal.HTTPS_PROXY = 'http://127.0.0.1';
-
-  expect(globalAgentGlobal.HTTPS_PROXY).toBe('http://127.0.0.1');
-});
-
-test('sets NO_PROXY', () => {
-  const globalAgentGlobal = createProxyController();
-
-  globalAgentGlobal.NO_PROXY = '*';
-
-  expect(globalAgentGlobal.NO_PROXY).toBe('*');
-});
-
-test('throws an error if unknown property is set', () => {
-  const globalAgentGlobal = createProxyController();
-
-  expect(() => {
-    // @ts-expect-error expected unknown property.
-    globalAgentGlobal.FOO = 'BAR';
-  }).toThrow('Cannot set an unmapped property "FOO".');
-});

package/src/factories/createProxyController.ts

@@ -1,51 +0,0 @@
-import {
-  logger,
-} from '../Logger';
-
-type ProxyController = {
-  HTTP_PROXY: string | null,
-  HTTPS_PROXY: string | null,
-  NO_PROXY: string | null,
-};
-
-const log = logger.child({
-  namespace: 'createProxyController',
-});
-
-const KNOWN_PROPERTY_NAMES = [
-  'HTTP_PROXY',
-  'HTTPS_PROXY',
-  'NO_PROXY',
-];
-
-export default (): ProxyController => {
-  // oxlint-disable-next-line fp/no-proxy
-  return new Proxy({
-    HTTP_PROXY: null,
-    HTTPS_PROXY: null,
-    NO_PROXY: null,
-  }, {
-    set: (subject, name, value) => {
-      if (typeof name !== 'string') {
-        throw new TypeError('Unexpected object member.');
-      }
-
-      if (!KNOWN_PROPERTY_NAMES.includes(name)) {
-        throw new Error('Cannot set an unmapped property "' + name + '".');
-      }
-
-      // @ts-expect-error string cannot be used to index an object
-      subject[name] = value;
-
-      log.info({
-        change: {
-          name,
-          value,
-        },
-        newConfiguration: subject,
-      }, 'configuration changed');
-
-      return true;
-    },
-  });
-};

package/src/factories/index.ts

@@ -1,6 +0,0 @@
-export {
-  default as createGlobalProxyAgent,
-} from './createGlobalProxyAgent';
-export {
-  default as createProxyController,
-} from './createProxyController';

package/src/index.ts

@@ -1,9 +0,0 @@
-export {
-  bootstrap,
-} from './routines';
-export {
-  createGlobalProxyAgent,
-} from './factories';
-export type {
-  Logger,
-} from './Logger';

package/src/routines/bootstrap.ts

@@ -1,28 +0,0 @@
-import createGlobalThis from 'globalthis';
-import {
-  logger,
-} from '../Logger';
-import {
-  createGlobalProxyAgent,
-} from '../factories';
-import type {
-  ProxyAgentConfigurationInputType,
-} from '../types';
-
-const globalThis: any = createGlobalThis();
-
-const log = logger.child({
-  namespace: 'bootstrap',
-});
-
-export default (configurationInput?: ProxyAgentConfigurationInputType): boolean => {
-  if (globalThis.GLOBAL_AGENT) {
-    log.warn('found globalThis.GLOBAL_AGENT; second attempt to bootstrap global-agent was ignored');
-
-    return false;
-  }
-
-  globalThis.GLOBAL_AGENT = createGlobalProxyAgent(configurationInput);
-
-  return true;
-};

package/src/routines/index.ts

@@ -1,3 +0,0 @@
-export {
-  default as bootstrap,
-} from './bootstrap';

package/src/types.ts

@@ -1,70 +0,0 @@
-import type {
-  Agent as HttpAgent,
-} from 'http';
-import type {
-  Agent as HttpsAgent,
-} from 'https';
-import type {
-  Socket,
-} from 'net';
-import type {
-  TLSSocket,
-} from 'tls';
-import type {
-  Logger,
-} from './Logger';
-
-export type ProxyConfigurationType = {
-  authorization: string | null,
-  hostname: string,
-  port: number,
-};
-
-export type TlsConfigurationType = {
-  ca?: string[] | string,
-  cert?: string,
-  ciphers?: string,
-  clientCertEngine?: string,
-  crl?: string,
-  dhparam?: string,
-  ecdhCurve?: string,
-  honorCipherOrder?: boolean,
-  key?: string,
-  passphrase?: string,
-  pfx?: string,
-  rejectUnauthorized?: boolean,
-  secureOptions?: number,
-  secureProtocol?: string,
-  servername?: string,
-  sessionIdContext?: string,
-};
-
-export type ConnectionConfigurationType = {
-  host: string,
-  port: number,
-  tls?: TlsConfigurationType,
-  proxy: ProxyConfigurationType,
-};
-
-export type ConnectionCallbackType = (error: Error | null, socket?: Socket | TLSSocket) => void;
-
-export type AgentType = HttpAgent | HttpsAgent;
-export type IsProxyConfiguredMethodType = () => boolean;
-export type MustUrlUseProxyMethodType = (url: string) => boolean;
-export type GetUrlProxyMethodType = (url: string) => ProxyConfigurationType;
-export type ProtocolType = 'http:' | 'https:';
-
-export type ProxyAgentConfigurationInputType = {
-  environmentVariableNamespace?: string,
-  forceGlobalAgent?: boolean,
-  socketConnectionTimeout?: number,
-  ca?: string[] | string,
-  logger?: Logger,
-};
-
-export type ProxyAgentConfigurationType = {
-  environmentVariableNamespace: string,
-  forceGlobalAgent: boolean,
-  socketConnectionTimeout: number,
-  ca?: string[] | string,
-};

package/src/utilities/bindHttpMethod.ts

@@ -1,53 +0,0 @@
-import http from 'http';
-import https from 'https';
-
-type AgentType = http.Agent | https.Agent;
-
-export default (
-  originalMethod: Function,
-  agent: AgentType,
-  forceGlobalAgent: boolean,
-) => {
-  return (...args: any[]) => {
-    let url;
-    let options;
-    let callback;
-
-    if (typeof args[0] === 'string' || args[0] instanceof URL) {
-      url = args[0];
-
-      if (typeof args[1] === 'function') {
-        options = {};
-        callback = args[1];
-      } else {
-        options = {
-          ...args[1],
-        };
-        callback = args[2];
-      }
-    } else {
-      options = {
-        ...args[0],
-      };
-      callback = args[1];
-    }
-
-    if (forceGlobalAgent) {
-      options.agent = agent;
-    } else {
-      if (!options.agent) {
-        options.agent = agent;
-      }
-
-      if (options.agent === http.globalAgent || options.agent === https.globalAgent) {
-        options.agent = agent;
-      }
-    }
-
-    if (url) {
-      return originalMethod(url, options, callback);
-    } else {
-      return originalMethod(options, callback);
-    }
-  };
-};

package/src/utilities/index.ts

@@ -1,9 +0,0 @@
-export {
-  default as bindHttpMethod,
-} from './bindHttpMethod';
-export {
-  default as isUrlMatchingNoProxy,
-} from './isUrlMatchingNoProxy';
-export {
-  default as parseProxyUrl,
-} from './parseProxyUrl';

package/src/utilities/isUrlMatchingNoProxy.test.ts

@@ -1,77 +0,0 @@
-import {
-  expect,
-  test,
-} from 'vitest';
-import isUrlMatchingNoProxy from './isUrlMatchingNoProxy';
-
-test('returns `true` if hosts match', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com/', 'foo.com')).toBe(true);
-});
-
-test('returns `true` if hosts match (IP)', () => {
-  expect(isUrlMatchingNoProxy('http://127.0.0.1/', '127.0.0.1')).toBe(true);
-});
-
-test('returns `true` if hosts match (using asterisk wildcard)', () => {
-  expect(isUrlMatchingNoProxy('http://bar.foo.com/', '*.foo.com')).toBe(true);
-});
-
-test('returns `true` if domain matches (using dot wildcard)', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com/', '.foo.com')).toBe(true);
-});
-
-test('returns `true` if subdomain matches (using dot wildcard)', () => {
-  expect(isUrlMatchingNoProxy('http://bar.foo.com/', '.foo.com')).toBe(true);
-});
-
-test('returns `true` if hosts match (*) and ports match', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com:8080/', '*:8080')).toBe(true);
-});
-
-test('returns `true` if hosts and ports match', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com:8080/', 'foo.com:8080')).toBe(true);
-});
-
-test('returns `true` if hosts match and NO_PROXY does not define port', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com:8080/', 'foo.com')).toBe(true);
-});
-
-test('returns `true` if hosts (IP) and ports match', () => {
-  expect(isUrlMatchingNoProxy('http://127.0.0.1:8080/', '127.0.0.1:8080')).toBe(true);
-});
-
-test('returns `false` if hosts match and ports do not match (diffferent port)', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com:8080/', 'foo.com:8000')).toBe(false);
-});
-
-test('returns `false` if hosts match and ports do not match (port not present subject)', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com/', 'foo.com:8000')).toBe(false);
-});
-
-test('returns `true` if hosts match and ports do not match (port not present NO_PROXY)', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com:8000/', 'foo.com')).toBe(true);
-});
-
-test('returns `true` if hosts match in one of multiple rules separated with a comma', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com/', 'bar.org,foo.com,baz.io')).toBe(true);
-});
-
-test('returns `true` if hosts match in one of multiple rules separated with a comma and a space', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com/', 'bar.org, foo.com, baz.io')).toBe(true);
-});
-
-test('returns `true` if hosts match in one of multiple rules separated with a space', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com/', 'bar.org foo.com baz.io')).toBe(true);
-});
-
-test('handles trailing newline in NO_PROXY', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com/', 'foo.com\n')).toBe(true);
-});
-
-test('handles trailing whitespace in NO_PROXY', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com/', 'foo.com   ')).toBe(true);
-});
-
-test('handles leading whitespace in NO_PROXY', () => {
-  expect(isUrlMatchingNoProxy('http://foo.com/', '  foo.com')).toBe(true);
-});

package/src/utilities/isUrlMatchingNoProxy.ts

@@ -1,32 +0,0 @@
-import matcher from 'matcher';
-import {
-  UnexpectedStateError,
-} from '../errors';
-
-export default (subjectUrl: string, noProxy: string) => {
-  const subjectUrlTokens = new URL(subjectUrl);
-
-  const rules = noProxy.split(/[\s,]+/).filter(Boolean);
-
-  for (const rule of rules) {
-    const ruleMatch = rule
-      .replace(/^(?<leadingDot>\.)/, '*')
-      .match(/^(?<hostname>.+?)(?::(?<port>\d+))?$/);
-
-    if (!ruleMatch || !ruleMatch.groups) {
-      throw new UnexpectedStateError('Invalid NO_PROXY pattern.');
-    }
-
-    if (!ruleMatch.groups.hostname) {
-      throw new UnexpectedStateError('NO_PROXY entry pattern must include hostname. Use * to match any hostname.');
-    }
-
-    const hostnameIsMatch = matcher.isMatch(subjectUrlTokens.hostname, ruleMatch.groups.hostname);
-
-    if (hostnameIsMatch && (!ruleMatch.groups || !ruleMatch.groups.port || subjectUrlTokens.port && subjectUrlTokens.port === ruleMatch.groups.port)) {
-      return true;
-    }
-  }
-
-  return false;
-};

package/src/utilities/parseBoolean.ts

@@ -1,17 +0,0 @@
-export const parseBoolean = function (value: any): boolean {
-  switch (Object.prototype.toString.call(value)) {
-    case '[object String]':
-      return ['true', 't', 'yes', 'y', 'on', '1'].includes(
-        value.trim().toLowerCase(),
-      );
-
-    case '[object Number]':
-      return value.valueOf() === 1;
-
-    case '[object Boolean]':
-      return value.valueOf();
-
-    default:
-      return false;
-  }
-};

package/src/utilities/parseProxyUrl.test.ts

@@ -1,35 +0,0 @@
-import {
-  expect,
-  test,
-} from 'vitest';
-import parseProxyUrl from './parseProxyUrl';
-
-test('extracts hostname', () => {
-  expect(parseProxyUrl('http://0.0.0.0').hostname).toBe('0.0.0.0');
-});
-
-test('extracts port', () => {
-  expect(parseProxyUrl('http://0.0.0.0:3000').port).toBe(3_000);
-});
-
-test('extracts authorization', () => {
-  expect(parseProxyUrl('http://foo:bar@0.0.0.0').authorization).toBe('foo:bar');
-});
-
-test('throws an error if protocol is not "http:"', () => {
-  expect(() => {
-    parseProxyUrl('https://0.0.0.0:3000');
-  }).toThrow('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL protocol must be "http:".');
-});
-
-test('throws an error if query is present', () => {
-  expect(() => {
-    parseProxyUrl('http://0.0.0.0:3000/?foo=bar');
-  }).toThrow('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have query.');
-});
-
-test('throws an error if hash is present', () => {
-  expect(() => {
-    parseProxyUrl('http://0.0.0.0:3000/#foo');
-  }).toThrow('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have hash.');
-});

package/src/utilities/parseProxyUrl.ts

@@ -1,39 +0,0 @@
-import {
-  UnexpectedStateError,
-} from '../errors';
-
-export default (url: string) => {
-  const urlTokens = new URL(url);
-
-  if (urlTokens.search !== '') {
-    throw new UnexpectedStateError('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have query.');
-  }
-
-  if (urlTokens.hash !== '') {
-    throw new UnexpectedStateError('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have hash.');
-  }
-
-  if (urlTokens.protocol !== 'http:') {
-    throw new UnexpectedStateError('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL protocol must be "http:".');
-  }
-
-  let port = 80;
-
-  if (urlTokens.port) {
-    port = Number.parseInt(urlTokens.port, 10);
-  }
-
-  let authorization = null;
-
-  if (urlTokens.username && urlTokens.password) {
-    authorization = urlTokens.username + ':' + urlTokens.password;
-  } else if (urlTokens.username) {
-    authorization = urlTokens.username;
-  }
-
-  return {
-    authorization,
-    hostname: urlTokens.hostname,
-    port,
-  };
-};