global-agent 2.2.0 → 4.0.0

package/{dist/routines/bootstrap.js.flow → src/routines/bootstrap.ts}

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

package/src/routines/index.ts

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

package/src/types.ts

@@ -0,0 +1,66 @@
+import type {
+  Agent as HttpAgent,
+} from 'http';
+import type {
+  Agent as HttpsAgent,
+} from 'https';
+import type {
+  Socket,
+} from 'net';
+import type {
+  TLSSocket,
+} from 'tls';
+
+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,
+};
+
+export type ProxyAgentConfigurationType = {
+  environmentVariableNamespace: string,
+  forceGlobalAgent: boolean,
+  socketConnectionTimeout: number,
+  ca?: string[] | string,
+};

package/src/utilities/{bindHttpMethod.js → bindHttpMethod.ts}

@@ -1,14 +1,14 @@
-// @flow
-
 import http from 'http';
 import https from 'https';
 
 type AgentType = http.Agent | https.Agent;
 
-// eslint-disable-next-line flowtype/no-weak-types
-export default (originalMethod: Function, agent: AgentType, forceGlobalAgent: boolean) => {
-  // eslint-disable-next-line unicorn/prevent-abbreviations
-  return (...args: *) => {
+export default (
+  originalMethod: Function,
+  agent: AgentType,
+  forceGlobalAgent: boolean,
+) => {
+  return (...args: any[]) => {
     let url;
     let options;
     let callback;
@@ -45,7 +45,6 @@ export default (originalMethod: Function, agent: AgentType, forceGlobalAgent: bo
     }
 
     if (url) {
-      // $FlowFixMe
       return originalMethod(url, options, callback);
     } else {
       return originalMethod(options, callback);

package/src/utilities/index.ts

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

package/{dist/utilities/isUrlMatchingNoProxy.js.flow → src/utilities/isUrlMatchingNoProxy.ts}

@@ -1,15 +1,10 @@
-// @flow
-
-import {
-  parse as parseUrl,
-} from 'url';
 import matcher from 'matcher';
 import {
   UnexpectedStateError,
 } from '../errors';
 
 export default (subjectUrl: string, noProxy: string) => {
-  const subjectUrlTokens = parseUrl(subjectUrl);
+  const subjectUrlTokens = new URL(subjectUrl);
 
   const rules = noProxy.split(/[\s,]+/);
 

package/src/utilities/parseBoolean.ts

@@ -0,0 +1,17 @@
+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.js → parseProxyUrl.ts}

@@ -1,20 +1,15 @@
-// @flow
-
-import {
-  parse as parseUrl,
-} from 'url';
 import {
   UnexpectedStateError,
 } from '../errors';
 
 export default (url: string) => {
-  const urlTokens = parseUrl(url);
+  const urlTokens = new URL(url);
 
-  if (urlTokens.query !== null) {
+  if (urlTokens.search !== '') {
     throw new UnexpectedStateError('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have query.');
   }
 
-  if (urlTokens.hash !== null) {
+  if (urlTokens.hash !== '') {
     throw new UnexpectedStateError('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have hash.');
   }
 
@@ -28,8 +23,16 @@ export default (url: string) => {
     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: urlTokens.auth || null,
+    authorization,
     hostname: urlTokens.hostname,
     port,
   };

package/test/.eslintrc

@@ -0,0 +1,10 @@
+{
+  "rules": {
+    "ava/use-test": 0,
+    "filenames/match-regex": 0,
+    "flowtype/no-flow-fix-me-comments": 0,
+    "flowtype/no-weak-types": 0,
+    "id-length": 0,
+    "node/no-unpublished-import": 0
+  }
+}