feat: add no_proxy env variable

src/gaxios.ts

@@ -42,8 +42,6 @@ function hasFetch() {
 
 let HttpsProxyAgent: any;
 
-// Figure out if we should be using a proxy. Only if it's required, load
-// the https-proxy-agent module as it adds startup cost.
 function loadProxy() {
   const proxy =
     process.env.HTTPS_PROXY ||
@@ -53,10 +51,63 @@ function loadProxy() {
   if (proxy) {
     HttpsProxyAgent = require('https-proxy-agent');
   }
-  return proxy;
 }
 loadProxy();
 
+function matchingProxyStrings(
+  envVarHTTPS: string | undefined,
+  envVarHTTP: string | undefined,
+  envVarhttps: string | undefined,
+  envVarhttp: string | undefined,
+  url: string
+) {
+  const arrayOfEnvVariables = (
+    envVarHTTPS ||
+    envVarHTTP ||
+    envVarhttps ||
+    envVarhttp
+  )?.split(',');
+
+  let isMatch;
+  if (arrayOfEnvVariables && arrayOfEnvVariables.length > 0) {
+    const parsedURL = new URL(url);
+    isMatch = arrayOfEnvVariables.find(url => {
+      if (url.startsWith('*.') || url.startsWith('.')) {
+        url = url.replace('*', '');
+        return parsedURL.hostname.endsWith(url);
+      } else {
+        return url === parsedURL.origin || url === parsedURL.hostname;
+      }
+    });
+  }
+  return isMatch;
+}
+
+// Figure out if we should be using a proxy. Only if it's required, load
+// the https-proxy-agent module as it adds startup cost.
+function getProxy(url: string) {
+  const shouldThisBeNoProxy = matchingProxyStrings(
+    process.env.no_proxy,
+    process.env.no_proxy,
+    undefined,
+    undefined,
+    url
+  );
+  // If there is a match between the no_proxy env variables and the url, then do not proxy
+  if (shouldThisBeNoProxy) {
+    return undefined;
+    // If there is not a match between the no_proxy env variables and the url, check to see if there should be a proxy
+  } else {
+    return matchingProxyStrings(
+      process.env.HTTPS_PROXY,
+      process.env.https_proxy,
+      process.env.HTTP_PROXY,
+      process.env.http_proxy,
+      url
+    );
+  }
+}
+
 export class Gaxios {
   private agentCache = new Map<
     string,
@@ -219,13 +270,14 @@ export class Gaxios {
     }
     opts.method = opts.method || 'GET';
 
-    const proxy = loadProxy();
+    const proxy = getProxy(opts.url);
     if (proxy) {
+      loadProxy();
       if (this.agentCache.has(proxy)) {
-        opts.agent = this.agentCache.get(proxy);
+        opts.agent = this.agentCache.get(opts.url);
       } else {
-        opts.agent = new HttpsProxyAgent(proxy);
-        this.agentCache.set(proxy, opts.agent!);
+        opts.agent = new HttpsProxyAgent(opts.url);
+        this.agentCache.set(opts.url, opts.agent!);
       }
     }
 

test/test.getch.ts

@@ -249,14 +249,181 @@ describe('🥁 configuration options', () => {
     assert.deepStrictEqual(res.data, {});
   });
 
-  it('should use an https proxy if asked nicely', async () => {
-    sandbox.stub(process, 'env').value({https_proxy: 'https://fake.proxy'});
-    const body = {hello: '🌎'};
-    const scope = nock(url).get('/').reply(200, body);
-    const res = await request({url});
-    scope.done();
-    assert.deepStrictEqual(res.data, body);
-    assert.ok(res.config.agent instanceof HttpsProxyAgent);
+  describe('proxying', () => {
+    it('should use an https proxy if asked nicely', async () => {
+      const url = 'https://fake.proxy';
+      sandbox.stub(process, 'env').value({https_proxy: 'https://fake.proxy'});
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.ok(res.config.agent instanceof HttpsProxyAgent);
+    });
+
+    it('should not proxy when url matches no_proxy', async () => {
+      const url = 'https://example.com';
+      sandbox.stub(process, 'env').value({
+        https_proxy: 'https://fake.proxy',
+        no_proxy: 'https://example.com',
+      });
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.strictEqual(res.config.agent, undefined);
+    });
+
+    it('should not proxy if url does not match either env variable', async () => {
+      const url = 'https://example2.com';
+      sandbox.stub(process, 'env').value({
+        https_proxy: 'https://fake.proxy',
+        no_proxy: 'https://example.com',
+      });
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.strictEqual(res.config.agent, undefined);
+    });
+
+    it('should not proxy if no_proxy URL matches the origin or hostname of the URL', async () => {
+      const url = 'https://example2.com';
+      sandbox.stub(process, 'env').value({
+        https_proxy: 'https://fake.proxy',
+        no_proxy: 'example2.com',
+      });
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.strictEqual(res.config.agent, undefined);
+    });
+
+    it('should proxy if proxy URL matches the origin or hostname of the URL', async () => {
+      const url = 'https://example2.com';
+      sandbox.stub(process, 'env').value({
+        https_proxy: 'example2.com',
+      });
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.ok(res.config.agent instanceof HttpsProxyAgent);
+    });
+
+    it('should not proxy if no_proxy env variable has asterisk', async () => {
+      const url = 'https://domain.example.com';
+      sandbox.stub(process, 'env').value({
+        https_proxy: 'https://fake.proxy',
+        no_proxy: '*.example.com',
+      });
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.strictEqual(res.config.agent, undefined);
+    });
+
+    it('should proxy if proxy env variable has asterisk', async () => {
+      const url = 'https://domain.example.com';
+      sandbox.stub(process, 'env').value({
+        https_proxy: '*.example.com',
+      });
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.ok(res.config.agent instanceof HttpsProxyAgent);
+    });
+
+    it('should not proxy if no_proxy env variable starts with a dot', async () => {
+      const url = 'https://domain.example.com';
+      sandbox.stub(process, 'env').value({
+        https_proxy: 'https://fake.proxy',
+        no_proxy: '.example.com',
+      });
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.strictEqual(res.config.agent, undefined);
+    });
+
+    it('should proxy if proxy env variable starts with a dot', async () => {
+      const url = 'https://domain.example.com';
+      sandbox.stub(process, 'env').value({
+        https_proxy: '.example.com',
+      });
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.ok(res.config.agent instanceof HttpsProxyAgent);
+    });
+
+    it('should allow comma-separated lists for no_proxy env variables', async () => {
+      const url = 'https://api.google.com';
+      sandbox.stub(process, 'env').value({
+        https_proxy: 'https://fake.proxy',
+        no_proxy: 'example.com,*.google.com,hello.com',
+      });
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.strictEqual(res.config.agent, undefined);
+    });
+
+    it('should allow comma-separated lists for proxy env variables', async () => {
+      const url = 'https://api.google.com';
+      sandbox.stub(process, 'env').value({
+        https_proxy: 'example.com,*.google.com,hello.com',
+      });
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.ok(res.config.agent instanceof HttpsProxyAgent);
+    });
+
+    it('should let no_proxy take precedence, if url is in both proxy and no_proxy env variables', async () => {
+      const url = 'https://example.com';
+      sandbox.stub(process, 'env').value({
+        https_proxy: 'example.com',
+        no_proxy: 'example.com',
+      });
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.strictEqual(res.config.agent, undefined);
+    });
+
+    it('should proxy if url is an exact match of proxy, but not of no_proxy', async () => {
+      const url = 'https://hello.example.com';
+      sandbox.stub(process, 'env').value({
+        https_proxy: 'https://hello.example.com',
+        no_proxy: 'example.com',
+      });
+      const body = {hello: '🌎'};
+      const scope = nock(url).get('/').reply(200, body);
+      const res = await request({url});
+      scope.done();
+      assert.deepStrictEqual(res.data, body);
+      assert.ok(res.config.agent instanceof HttpsProxyAgent);
+    });
   });
 
   it('should load the proxy from the cache', async () => {