@automattic/vip 4.1.6 → 4.1.8

package/node_modules/fetch-retry/index.js

@@ -1,143 +0,0 @@
-'use strict';
-
-module.exports = function (fetch, defaults) {
-  defaults = defaults || {};
-  if (typeof fetch !== 'function') {
-    throw new ArgumentError('fetch must be a function');
-  }
-
-  if (typeof defaults !== 'object') {
-    throw new ArgumentError('defaults must be an object');
-  }
-
-  if (defaults.retries !== undefined && !isPositiveInteger(defaults.retries)) {
-    throw new ArgumentError('retries must be a positive integer');
-  }
-
-  if (defaults.retryDelay !== undefined && !isPositiveInteger(defaults.retryDelay) && typeof defaults.retryDelay !== 'function') {
-    throw new ArgumentError('retryDelay must be a positive integer or a function returning a positive integer');
-  }
-
-  if (defaults.retryOn !== undefined && !Array.isArray(defaults.retryOn) && typeof defaults.retryOn !== 'function') {
-    throw new ArgumentError('retryOn property expects an array or function');
-  }
-
-  var baseDefaults = {
-    retries: 3,
-    retryDelay: 1000,
-    retryOn: [],
-  };
-
-  defaults = Object.assign(baseDefaults, defaults);
-
-  return function fetchRetry(input, init) {
-    var retries = defaults.retries;
-    var retryDelay = defaults.retryDelay;
-    var retryOn = defaults.retryOn;
-
-    if (init && init.retries !== undefined) {
-      if (isPositiveInteger(init.retries)) {
-        retries = init.retries;
-      } else {
-        throw new ArgumentError('retries must be a positive integer');
-      }
-    }
-
-    if (init && init.retryDelay !== undefined) {
-      if (isPositiveInteger(init.retryDelay) || (typeof init.retryDelay === 'function')) {
-        retryDelay = init.retryDelay;
-      } else {
-        throw new ArgumentError('retryDelay must be a positive integer or a function returning a positive integer');
-      }
-    }
-
-    if (init && init.retryOn) {
-      if (Array.isArray(init.retryOn) || (typeof init.retryOn === 'function')) {
-        retryOn = init.retryOn;
-      } else {
-        throw new ArgumentError('retryOn property expects an array or function');
-      }
-    }
-
-    // eslint-disable-next-line no-undef
-    return new Promise(function (resolve, reject) {
-      var wrappedFetch = function (attempt) {
-        // As of node 18, this is no longer needed since node comes with native support for fetch:
-        /* istanbul ignore next */
-        var _input =
-          typeof Request !== 'undefined' && input instanceof Request
-            ? input.clone()
-            : input;
-        fetch(_input, init)
-          .then(function (response) {
-            if (Array.isArray(retryOn) && retryOn.indexOf(response.status) === -1) {
-              resolve(response);
-            } else if (typeof retryOn === 'function') {
-              try {
-                // eslint-disable-next-line no-undef
-                return Promise.resolve(retryOn(attempt, null, response))
-                  .then(function (retryOnResponse) {
-                    if(retryOnResponse) {
-                      retry(attempt, null, response);
-                    } else {
-                      resolve(response);
-                    }
-                  }).catch(reject);
-              } catch (error) {
-                reject(error);
-              }
-            } else {
-              if (attempt < retries) {
-                retry(attempt, null, response);
-              } else {
-                resolve(response);
-              }
-            }
-          })
-          .catch(function (error) {
-            if (typeof retryOn === 'function') {
-              try {
-                // eslint-disable-next-line no-undef
-                Promise.resolve(retryOn(attempt, error, null))
-                  .then(function (retryOnResponse) {
-                    if(retryOnResponse) {
-                      retry(attempt, error, null);
-                    } else {
-                      reject(error);
-                    }
-                  })
-                  .catch(function(error) {
-                    reject(error);
-                  });
-              } catch(error) {
-                reject(error);
-              }
-            } else if (attempt < retries) {
-              retry(attempt, error, null);
-            } else {
-              reject(error);
-            }
-          });
-      };
-
-      function retry(attempt, error, response) {
-        var delay = (typeof retryDelay === 'function') ?
-          retryDelay(attempt, error, response) : retryDelay;
-        setTimeout(function () {
-          wrappedFetch(++attempt);
-        }, delay);
-      }
-
-      wrappedFetch(0);
-    });
-  };
-};
-
-function isPositiveInteger(value) {
-  return Number.isInteger(value) && value >= 0;
-}
-
-function ArgumentError(message) {
-  this.name = 'ArgumentError';
-  this.message = message;
-}

package/node_modules/fetch-retry/package.json

@@ -1,41 +0,0 @@
-{
-  "name": "fetch-retry",
-  "version": "6.0.0",
-  "description": "Extend any fetch library with retry functionality",
-  "repository": "https://github.com/jonbern/fetch-retry.git",
-  "main": "index.js",
-  "browser": "dist/fetch-retry.umd.js",
-  "types": "index.d.ts",
-  "scripts": {
-    "lint": "eslint index.js ./test/**/*.js",
-    "test": "nyc mocha test/**/**.js && npm run lint",
-    "integration-test": "mocha test/integration/",
-    "build": "rollup -c",
-    "prepare": "node -e \"try { require('husky').install() } catch (e) {if (e.code !== 'MODULE_NOT_FOUND') throw e}\""
-  },
-  "keywords": [
-    "fetch",
-    "retry",
-    "http",
-    "retry",
-    "Fetch API"
-  ],
-  "author": "Jon K. Bernhardsen",
-  "license": "MIT",
-  "dependencies": {},
-  "devDependencies": {
-    "body-parser": "^1.19.0",
-    "chai": "^4.2.0",
-    "chai-as-promised": "^7.1.1",
-    "eslint": "^6.8.0",
-    "expectations": "^0.7.1",
-    "express": "^4.17.1",
-    "husky": "^7.0.0",
-    "mocha": "^10.2.0",
-    "node-fetch": "^2.6.9",
-    "nyc": "^14.1.1",
-    "rollup": "^2.52.3",
-    "@rollup/plugin-commonjs": "^19.0.0",
-    "sinon": "^6.3.5"
-  }
-}

package/node_modules/fetch-retry/rollup.config.js

@@ -1,12 +0,0 @@
-import commonjs from '@rollup/plugin-commonjs';
-import pkg from './package.json';
-
-export default {
-  input: 'index.js',
-  output: {
-    name: 'fetchRetry',
-    file: pkg.browser,
-    format: 'umd'
-  },
-  plugins: [commonjs()]
-};

package/node_modules/fetch-retry/test/.eslintrc.yml

@@ -1,7 +0,0 @@
-env:
-  node: true
-  mocha: true
-parserOptions:
-  ecmaVersion: 10
-rules:
-  no-console: 0

package/node_modules/fetch-retry/test/integration/index.js

@@ -1,212 +0,0 @@
-'use strict';
-const chai = require('chai');
-const chaiAsPromised = require('chai-as-promised');
-chai.use(chaiAsPromised);
-chai.should();
-const childProcess = require('child_process');
-const fetch = require('node-fetch');
-const fetchRetry = require('../../')(fetch);
-
-describe('fetch-retry integration tests', () => {
-
-  const baseUrl = 'http://localhost:3000/mock';
-
-  before(() => {
-    const process = childProcess.fork('./test/integration/mock-api/index.js');
-
-    process.on('error', err => {
-      console.log(err);
-    });
-  });
-
-  after(() => {
-    return fetchRetry(baseUrl + '/stop', {
-      method: 'POST'
-    });
-  });
-
-  const setupResponses = (responses) => {
-    return fetchRetry(baseUrl, {
-      method: 'POST',
-      body: JSON.stringify(responses),
-      headers: {
-        'content-type': 'application/json'
-      }
-    });
-  };
-
-  const getCallCount = () => {
-    return fetchRetry(`${baseUrl}/calls`)
-      .then(response => {
-        return response.text();
-      })
-      .then(text => {
-        return Number.parseInt(text);
-      });
-  };
-
-  [
-    ['with url string', (baseUrl, init) => fetchRetry(baseUrl, init)],
-    ['with URL type', (baseUrl, init) => {
-      const url = new URL(baseUrl);
-      return fetchRetry(url, init);
-    }],
-    ['with Request argument', (baseUrl, init) => {
-      const request = new fetch.Request(baseUrl);
-      return fetchRetry(request, init);
-    }], 
-  ].forEach(([usagePatternDescription, fetchInvocation]) => {
-
-    describe(usagePatternDescription, () => {
-
-      [200, 503, 404].forEach(statusCode => {
-
-        describe('when endpoint returns ' + statusCode, () => {
-    
-          before(() => {
-            return setupResponses([statusCode]);
-          });
-    
-          it('does not retry request', () => {
-            return fetchInvocation(baseUrl)
-              .then(getCallCount)
-              .should.eventually.equal(1);
-          });
-    
-        });
-    
-      });
-    
-      describe('when configured to retry on a specific HTTP code', () => {
-    
-        describe('and it never succeeds', () => {
-    
-          const retryOn = [503];
-    
-          beforeEach(() => {
-            return setupResponses([503, 503, 503, 503]);
-          });
-    
-          it('retries the request #retries times', () => {
-            const init = {
-              retries: 3,
-              retryDelay: 100,
-              retryOn
-            };
-    
-            const expectedCallCount = init.retries + 1;
-    
-            return fetchInvocation(baseUrl, init)
-              .then(getCallCount)
-              .should.eventually.equal(expectedCallCount);
-          });
-    
-          it('eventually resolves the promise with the response of the last request', () => {
-            const init = {
-              retries: 3,
-              retryDelay: 100,
-              retryOn
-            };
-    
-            const expectedResponse = {
-              status: 503,
-              ok: false
-            };
-    
-            return fetchInvocation(baseUrl, init)
-              .then(response => {
-                return {
-                  status: response.status,
-                  ok: response.ok
-                };
-              })
-              .should.become(expectedResponse);
-          });
-    
-        });
-    
-        describe('and it eventually succeeds', () => {
-    
-          const retryOnStatus = 503;
-          const responses = [503, 503, 200];
-          const requestsToRetry = responses
-            .filter(response => response === retryOnStatus)
-            .length;
-    
-          beforeEach(() => {
-            return setupResponses(responses);
-          });
-    
-          it('retries the request up to #retries times', () => {
-            const init = {
-              retries: 3,
-              retryDelay: 100,
-              retryOn: [retryOnStatus]
-            };
-    
-            const expectedCallCount = requestsToRetry + 1;
-    
-            return fetchInvocation(baseUrl, init)
-              .then(getCallCount)
-              .should.eventually.equal(expectedCallCount);
-          });
-    
-          it('eventually resolves the promise with the received response of the last request', () => {
-            const init = {
-              retries: 3,
-              retryDelay: 100,
-              retryOn: [retryOnStatus]
-            };
-    
-            const expectedResponse = {
-              status: 200,
-              ok: true
-            };
-    
-            return fetchInvocation(baseUrl, init)
-              .then(response => {
-                return {
-                  status: response.status,
-                  ok: response.ok
-                };
-              })
-              .should.become(expectedResponse);
-          });
-    
-        });
-    
-      });
-    
-      describe('when configured to retry on a set of HTTP codes', () => {
-    
-        describe('and it never succeeds', () => {
-    
-          const retryOn = [503, 404];
-    
-          beforeEach(() => {
-            return setupResponses([503, 404, 404, 503]);
-          });
-    
-          it('retries the request #retries times', () => {
-            const init = {
-              retries: 3,
-              retryDelay: 100,
-              retryOn
-            };
-    
-            const expectedCallCount = init.retries + 1;
-    
-            return fetchInvocation(baseUrl, init)
-              .then(getCallCount)
-              .should.eventually.equal(expectedCallCount);
-          });
-    
-        });
-    
-      });
-  
-    });
-
-  });
-
-});

package/node_modules/fetch-retry/test/integration/mock-api/index.js

@@ -1,42 +0,0 @@
-const express = require('express');
-const app = express();
-const bodyParser = require('body-parser');
-
-app.use(bodyParser.urlencoded({ extended: true }));
-app.use(bodyParser.json());
-
-app.use((req, res, next) => {
-  res.header('Access-Control-Allow-Origin', '*');
-  res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
-  next();
-});
-
-let server;
-let calls = 0;
-let responses = [];
-
-app.post('/mock', (req, res) => {
-  responses = req.body;
-  calls = 0;
-  res.status(200).send(responses);
-});
-
-app.get('/mock', (req, res) => {
-  if (responses.length === 0) {
-    res.status(501).send('Mock API is not configured to return anything');
-  } else {
-    calls++;
-    res.status(responses.shift()).send();
-  }
-});
-
-app.get('/mock/calls', (req, res) => {
-  res.status(200).send(calls.toString());
-});
-
-app.post('/mock/stop', (req, res) => {
-  res.status(200).send();
-  server.close();
-});
-
-server = app.listen(3000);