@leverege/build-tools 1.8.4

package/lib/server/pkgck

@@ -0,0 +1,136 @@
+#!/bin/bash
+
+C_off='\e[0m'
+C_yellow='\e[93m'
+C_red='\e[101m'
+C_green='\e[92m'
+
+good() {
+  printf "\e[32m✔${C_off}"
+}
+
+bad() {
+  printf "\e[31m✘${C_off}"
+}
+
+semver() {
+  local version=$1
+  local isSemver=`echo $version | egrep -e "^v\d+\.\d+\.\d+$"`
+  if [ -z "$version" ];
+  then
+    printf "UNTAGGD"
+  elif [ $isSemver ];
+  then
+    printf "$version"
+  else
+    printf "!SEMVER"
+  fi
+}
+
+check_babel () {
+  local C_stat=$(bad)
+  [ -f .babelrc ] && grep --silent @babel/plugin-proposal-optional-chaining .babelrc
+  [ $? -eq 0 ] && C_stat=$(good)
+  printf $C_stat
+}
+
+check_circle () {
+  local C_stat=$(bad)
+  [ -f ".circleci/config.yml" ] && C_stat=$(good)
+  printf $C_stat
+}
+
+check_eslint () {
+  local C_stat=$(bad)
+  [ -f .eslintrc ] && grep --silent @leverege/eslint-config-leverege .eslintrc
+  [ $? -eq 0 ] && C_stat=$(good)
+  printf $C_stat
+}
+
+check_license () {
+  local C_stat=$(bad)
+  local lic="`node -p \"require('./package.json').scripts.licenseCheck !== undefined\"`"
+  [ $lic == true ] && C_stat=$(good)
+  printf $C_stat
+}
+
+# Invoke as: version_ck $GITTAG $NPMVER
+#
+check_git_version() {
+  local tag=$1
+  local pkg=$2
+  local clr=$C_green
+
+  if [ "$tag" == 'UNTAGGD' ];
+  then
+    clr=$C_red
+  elif [ "$tag" != "$pkg" ];
+  then
+    clr=$C_yellow
+  fi
+
+  printf "$clr$tag$C_off"
+}
+
+check_nodemon() {
+  nodemon="`getjson --file ./package.json --key nodemon`"
+}
+
+check_scope() {
+  private="`node -p \"require('./package.json').private == true\"`"
+  scoped="`getjson --file ./package.json --key name --regex '^@\w{3}'`"
+  result="${C_red}PUBL${C_off}"
+  if [[ "$scoped" == "" ]] && [[ "$private" == "true" ]];
+  then
+    result="${C_yellow}PRVT"
+  elif [[ "$scoped" != "" ]];
+  then
+    result="${C_green}${scoped}"
+  elif [[ "$private" == "true" ]];
+  then
+    result="${C_green}prv"
+  fi
+  printf "${result}${C_off}"
+}
+
+repos=0
+check_repo() {
+  local dir=$1
+  [ ! -d $dir/.git ] || [ ! -f $dir/package.json ] && return
+  cd $dir &> /dev/null
+  local gperrs=0
+  git pull -q &> /dev/null;        [ $? -ne 0 ] && let "gperrs++"
+  git pull -q --tags &> /dev/null; [ $? -ne 0 ] && let "gperrs++"
+
+  # It is necessary to use the output from printf to set localmods in order
+  # to get the ANSI escape codes expanded.
+  local localmods=$(good)
+  [ $gperrs -ne 0 ] && localmods=$(bad)
+  pkgver=$(semver "v`node -p \"require('./package.json').version\"`")
+  gitver=$(semver `git describe --abbrev=0 2>/dev/null`)
+  [ $? -ne 0 ] && gitver='UNTAGGD'
+  local needspush=
+  if [ "$pkgver" == "$gitver" ];
+  then
+    git ls-remote --tags origin | grep $gitver &> /dev/null
+    [ $? -ne 0 ] && needspush='!tags'
+  fi
+  local babel7=$(check_babel)
+  local circle=$(check_circle)
+  local eslint=$(check_eslint)
+  local license=$(check_license)
+  local scoped=$(check_scope)
+  [ $(( $repos % 15)) -eq 0 ] && printf "\n%35s pkg      git  cln scop cir lic esl bl7\n"
+  printf "%32s: %-8s %-16s %s  %8s  %s   %s   %s   %s  %s\n" $dir $pkgver $(check_git_version $gitver $pkgver) $localmods $scoped $circle $license $eslint $babel7 "$needspush"
+  let "repos++"
+  cd - &> /dev/null
+}
+
+clear
+
+pkgs="$@"
+for dir in $@; do
+  check_repo $dir
+done
+
+printf "\ntotal repoitories checked: $repos\n\n"

package/lib/server/pkglint/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+"use strict";
+
+const glob = require('glob');
+
+const filesToCheck = ['README.md', 'LICENSE.md'];
+const mdFiles = glob.sync('*.md'); // from https://github.com/lodash/lodash/issues/1743
+
+function arrayContainsArray(superset, subset) {
+  if (subset.length === 0) {
+    return false;
+  }
+
+  return subset.every(value => {
+    return superset.indexOf(value) >= 0;
+  });
+}
+
+arrayContainsArray(mdFiles, filesToCheck) ? console.log('README and LICENSE files exist') : process.exit(1);

package/lib/server/test.json

@@ -0,0 +1,4 @@
+{
+  "name": "@leverege/packagename",
+  "main": "lib/index.js"
+}

package/lib/web/auditate/help.js

@@ -0,0 +1,158 @@
+"use strict";
+
+require("core-js/modules/es7.symbol.async-iterator");
+
+require("core-js/modules/es6.symbol");
+
+require("core-js/modules/es6.regexp.split");
+
+require("core-js/modules/web.dom.iterable");
+
+require("core-js/modules/es6.array.iterator");
+
+require("core-js/modules/es6.object.to-string");
+
+require("core-js/modules/es6.object.keys");
+
+require("core-js/modules/es6.array.find");
+
+require("core-js/modules/es6.object.assign");
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var groupBy = require('lodash.groupby');
+
+var keyBy = require('lodash.keyby');
+
+var countBy = require('lodash.countby');
+
+var orderBy = require('lodash.orderby');
+
+var map = require('lodash.map');
+
+var first = require('lodash.first');
+
+module.exports = function () {
+  var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  function affectsProd(resolves) {
+    return !(config['prod-only'] && resolves.every(function (_ref) {
+      var dev = _ref.dev;
+      return dev;
+    }));
+  }
+
+  function requireAttention(auditResult) {
+    var actions = auditResult.actions,
+        advisories = auditResult.advisories;
+    var reviewActions = actions.filter(function (_ref2) {
+      var action = _ref2.action,
+          resolves = _ref2.resolves,
+          isMajor = _ref2.isMajor;
+      return (action === 'review' || isMajor) && affectsProd(resolves);
+    });
+    var reviewAdvisories = reviewActions.reduce(function (acc, _ref3) {
+      var resolves = _ref3.resolves;
+      var advisoriesToInclude = resolves.reduce(function (result, _ref4) {
+        var id = _ref4.id;
+        return Object.assign({}, result, _defineProperty({}, id, advisories[id]));
+      }, {});
+      return Object.assign({}, acc, advisoriesToInclude);
+    }, {});
+    return Object.assign({}, auditResult, {
+      actions: reviewActions,
+      advisories: reviewAdvisories
+    });
+  }
+
+  function getHighestSeverity(_ref5) {
+    var advisories = _ref5.advisories;
+
+    var _loop = function _loop() {
+      var severity = _arr[_i];
+
+      if (Object.keys(advisories).find(function (key) {
+        return advisories[key].severity === severity;
+      })) {
+        return {
+          v: severity
+        };
+      }
+    };
+
+    for (var _i = 0, _arr = ['critical', 'high', 'moderate', 'low']; _i < _arr.length; _i++) {
+      var _ret = _loop();
+
+      if (_typeof(_ret) === "object") return _ret.v;
+    }
+  }
+
+  function filterAuditResultsBySeverity(auditResult, highestSeverity) {
+    var actions = auditResult.actions,
+        advisories = auditResult.advisories;
+    var groupedAdvisories = groupBy(advisories, 'severity');
+    var advisoriesForSeverity = keyBy(groupedAdvisories[highestSeverity], 'id');
+    var actionsForSeverity = actions.reduce(function (acc, action) {
+      var resolvesSevereAdvisory = action.resolves.some(function (_ref6) {
+        var id = _ref6.id;
+        return advisoriesForSeverity[id];
+      });
+      return resolvesSevereAdvisory ? [].concat(acc, action) : acc;
+    }, []);
+    return Object.assign({}, auditResult, {
+      actions: actionsForSeverity,
+      advisories: advisories
+    });
+  }
+
+  function getAutoFixCount(auditResult) {
+    return auditResult.actions.filter(function (_ref7) {
+      var action = _ref7.action,
+          resolves = _ref7.resolves,
+          isMajor = _ref7.isMajor;
+      return action !== 'review' && !isMajor && affectsProd(resolves);
+    }).length;
+  }
+
+  function findRootLibs(resolves) {
+    return resolves.reduce(function (acc, resolve) {
+      return [].concat(acc, resolve.path.split('>')[0]);
+    }, []);
+  }
+
+  function getMostProblematicDependency(_ref8) {
+    var actions = _ref8.actions;
+    var rootLibraries = actions.reduce(function (libs, _ref9) {
+      var resolves = _ref9.resolves;
+      return [].concat(libs, findRootLibs(resolves));
+    }, []);
+    return first(orderBy(map(countBy(rootLibraries), function (count, lib) {
+      return {
+        count: count,
+        name: lib
+      };
+    }), function (_ref10) {
+      var count = _ref10.count;
+      return count;
+    }, ['desc']));
+  }
+
+  return function help(npmAuditResultJson) {
+    var npmAuditResult = JSON.parse(npmAuditResultJson);
+    var resultsThatRequireAttention = requireAttention(npmAuditResult);
+    var highestSeverity = getHighestSeverity(resultsThatRequireAttention);
+    var auditResult = filterAuditResultsBySeverity(resultsThatRequireAttention, highestSeverity);
+    var autoFixCount = getAutoFixCount(npmAuditResult);
+    var exitCode = config['exit-zero'] || !auditResult.actions.length && !autoFixCount ? 0 : 1;
+    return {
+      npmAuditResult: npmAuditResult,
+      auditResult: auditResult,
+      autoFixCount: autoFixCount,
+      mostProblematicDependency: getMostProblematicDependency(resultsThatRequireAttention),
+      highestSeverity: highestSeverity,
+      exitCode: exitCode
+    };
+  };
+};

package/lib/web/auditate/index.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+"use strict";
+
+require("core-js/modules/es6.object.assign");
+
+var getStdin = require('get-stdin');
+
+var options = require('minimist')(process.argv.slice(2));
+
+var help = require('./help');
+
+var report = require('./report');
+
+var defaults = {
+  'exit-zero': false,
+  'prod-only': false
+};
+var config = Object.assign({}, defaults, options);
+getStdin().then(help(config)).then(function (result) {
+  return report(result).then(function (theReport) {
+    console.log(theReport);
+    process.exit(result.exitCode);
+  });
+}).catch(function (error) {
+  console.error(error);
+  process.exit(1);
+});

package/lib/web/auditate/report.js

@@ -0,0 +1,91 @@
+"use strict";
+
+require("core-js/modules/es6.promise");
+
+require("regenerator-runtime/runtime");
+
+require("core-js/modules/web.dom.iterable");
+
+require("core-js/modules/es6.array.iterator");
+
+require("core-js/modules/es6.object.to-string");
+
+require("core-js/modules/es6.object.keys");
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var auditReport = require('npm-audit-report');
+
+var chalk = require('chalk');
+
+function automaticFixes(autoFixCount) {
+  return autoFixCount ? "run ".concat(chalk.yellow('`npm audit fix`'), " to automatically fix ").concat(chalk.yellow(autoFixCount), " issues. These should all be non-breaking upgrades, so don't stress.") : '';
+}
+
+function fixesToReview(_ref, highestSeverity) {
+  var actions = _ref.actions,
+      advisories = _ref.advisories;
+  var advisoryIds = Object.keys(advisories);
+
+  if (!actions.length || !advisoryIds.length) {
+    return '';
+  }
+
+  return "Resolve the ".concat(chalk.green(actions.length), " ").concat(chalk.green(highestSeverity), " severity issues above and run this command again to move to the next severity.");
+}
+
+function mostProblematic(mostProblematicDependency) {
+  if (!mostProblematicDependency) {
+    return '';
+  }
+
+  var name = mostProblematicDependency.name,
+      count = mostProblematicDependency.count;
+  return count && count > 2 ? "The most problematic dependency seems to be ".concat(chalk.blue(name), " with ").concat(chalk.blue(count), " issue").concat(count ? 's' : '', " that need your attention.") : '';
+}
+
+module.exports =
+/*#__PURE__*/
+function () {
+  var _printFullReport = _asyncToGenerator(
+  /*#__PURE__*/
+  regeneratorRuntime.mark(function _callee(_ref2) {
+    var npmAuditResult, auditResult, autoFixCount, mostProblematicDependency, highestSeverity, _ref3, report, hints, help;
+
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            npmAuditResult = _ref2.npmAuditResult, auditResult = _ref2.auditResult, autoFixCount = _ref2.autoFixCount, mostProblematicDependency = _ref2.mostProblematicDependency, highestSeverity = _ref2.highestSeverity;
+            _context.next = 3;
+            return auditReport(npmAuditResult, {
+              reporter: 'install',
+              withColor: true,
+              withUnicode: true
+            });
+
+          case 3:
+            _ref3 = _context.sent;
+            report = _ref3.report;
+            hints = [].concat(automaticFixes(autoFixCount)).concat(fixesToReview(auditResult, highestSeverity)).concat(mostProblematic(mostProblematicDependency)).filter(Boolean);
+            help = hints.length ? "\n\n".concat(chalk.green('=== A little bit of help ==='), "\n\nWhere to start:\n").concat(hints.reduce(function (acc, hint) {
+              return "".concat(acc, "\n- ").concat(hint, "\n");
+            }, ''), "\n") : '';
+            return _context.abrupt("return", "".concat(report).concat(help));
+
+          case 8:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  function printFullReport(_x) {
+    return _printFullReport.apply(this, arguments);
+  }
+
+  return printFullReport;
+}();

package/lib/web/dnsify/CloudflareAPI.js

@@ -0,0 +1,250 @@
+"use strict";
+
+require("core-js/modules/es7.symbol.async-iterator");
+
+require("core-js/modules/es6.symbol");
+
+require("core-js/modules/web.dom.iterable");
+
+require("core-js/modules/es6.promise");
+
+require("core-js/modules/es6.regexp.to-string");
+
+require("core-js/modules/es6.object.to-string");
+
+require("regenerator-runtime/runtime");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var ora = require('ora');
+
+var fs = require('fs');
+
+var path = require('path');
+
+var _require = require('util'),
+    promisify = _require.promisify;
+
+var CloudflareAPI =
+/*#__PURE__*/
+function () {
+  function CloudflareAPI(options) {
+    _classCallCheck(this, CloudflareAPI);
+
+    var args = options.args;
+    var url = args.url,
+        proxy = args.proxy,
+        ipaddress = args.ipaddress,
+        account = args.account;
+    this.url = url;
+    this.proxy = proxy;
+    this.ipaddress = ipaddress;
+    this.spinner = ora({
+      text: 'Creating DNS record...',
+      spinner: 'monkey'
+    });
+    this.account = account;
+  }
+
+  _createClass(CloudflareAPI, [{
+    key: "decrypt",
+    value: function () {
+      var _decrypt = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee() {
+        var projectId,
+            keyRingId,
+            cryptoKeyId,
+            ciphertextFileName,
+            plaintextFileName,
+            kms,
+            client,
+            locationId,
+            readFile,
+            contentsBuffer,
+            name,
+            ciphertext,
+            _ref,
+            _ref2,
+            result,
+            writeFile,
+            _args = arguments;
+
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                projectId = _args.length > 0 && _args[0] !== undefined ? _args[0] : 'leverege-docker-images';
+                keyRingId = _args.length > 1 && _args[1] !== undefined ? _args[1] : 'build-tools';
+                cryptoKeyId = _args.length > 2 && _args[2] !== undefined ? _args[2] : 'circle-ci';
+                ciphertextFileName = _args.length > 3 && _args[3] !== undefined ? _args[3] : './accounts.json.enc';
+                plaintextFileName = _args.length > 4 && _args[4] !== undefined ? _args[4] : './accounts.json';
+                // Import the library and create a client
+                kms = require('@google-cloud/kms');
+                client = new kms.KeyManagementServiceClient(); // The location of the crypto key's key ring, e.g. "global"
+
+                locationId = 'us-east4'; // Reads the file to be decrypted
+
+                readFile = promisify(fs.readFile);
+                _context.next = 11;
+                return readFile(path.resolve(__dirname, ciphertextFileName));
+
+              case 11:
+                contentsBuffer = _context.sent;
+                name = client.cryptoKeyPath(projectId, locationId, keyRingId, cryptoKeyId);
+                ciphertext = contentsBuffer.toString('base64'); // Decrypts the file using the specified crypto key
+
+                _context.next = 16;
+                return client.decrypt({
+                  name: name,
+                  ciphertext: ciphertext
+                });
+
+              case 16:
+                _ref = _context.sent;
+                _ref2 = _slicedToArray(_ref, 1);
+                result = _ref2[0];
+                // Writes the decrypted file to disk
+                writeFile = promisify(fs.writeFile);
+                _context.next = 22;
+                return writeFile(path.resolve(__dirname, plaintextFileName), Buffer.from(result.plaintext, 'base64'));
+
+              case 22:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function decrypt() {
+        return _decrypt.apply(this, arguments);
+      }
+
+      return decrypt;
+    }()
+  }, {
+    key: "setAccountValues",
+    value: function setAccountValues() {
+      var accountJson = require(path.resolve(__dirname, './accounts.json'));
+
+      var accountInfo = accountJson[this.account];
+      var email = accountInfo.email,
+          key = accountInfo.key,
+          zone = accountInfo.zone;
+      this.cf = require('cloudflare')({
+        email: email,
+        key: key
+      });
+      this.zone = zone;
+    }
+  }, {
+    key: "deleteSecrets",
+    value: function () {
+      var _deleteSecrets = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee2() {
+        var deleteFile;
+        return regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                deleteFile = promisify(fs.unlink);
+                _context2.next = 3;
+                return deleteFile(path.resolve(__dirname, './accounts.json'));
+
+              case 3:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      function deleteSecrets() {
+        return _deleteSecrets.apply(this, arguments);
+      }
+
+      return deleteSecrets;
+    }()
+  }, {
+    key: "createDNSRecord",
+    value: function () {
+      var _createDNSRecord = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee3() {
+        return regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.prev = 0;
+                this.spinner.start();
+                this.spinner.text = 'Decrypting Cloudflare secrets...';
+                _context3.next = 5;
+                return this.decrypt();
+
+              case 5:
+                this.spinner.text = 'Initializing Cloudflare API...';
+                this.setAccountValues();
+                this.spinner.text = 'Adding A name record...';
+                _context3.next = 10;
+                return this.cf.dnsRecords.add(this.zone, {
+                  type: 'A',
+                  name: this.url,
+                  content: this.ipaddress,
+                  proxied: this.proxy
+                });
+
+              case 10:
+                this.spinner.text = 'Removing secrets...';
+                _context3.next = 13;
+                return this.deleteSecrets();
+
+              case 13:
+                this.spinner.stop();
+                _context3.next = 21;
+                break;
+
+              case 16:
+                _context3.prev = 16;
+                _context3.t0 = _context3["catch"](0);
+                this.spinner.stop();
+                console.log(_context3.t0);
+                throw _context3.t0;
+
+              case 21:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this, [[0, 16]]);
+      }));
+
+      function createDNSRecord() {
+        return _createDNSRecord.apply(this, arguments);
+      }
+
+      return createDNSRecord;
+    }()
+  }]);
+
+  return CloudflareAPI;
+}();
+
+module.exports = CloudflareAPI;