polarity-integration-utils 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2017 Breach Intelligence, Inc., 2020 Polarity.IO Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# Polarity Integration Utils
+
+This library is intended for use in development of Polarity Integrations.
+
+
+
+## Contribution Instructions
+
+> NOTE: Don't forget to add your implementations to the `./test/index.test.js` to ensure your implementation is accessible from the main index.js

package/dist/es/errors/RequestError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RequestError extends Error {
+    constructor(message, status, description, requestOptions) {
+        super();
+        this.message = `Request Error${message ? ` -> ${message}` : ''}`;
+        this.status = status;
+        this.description = description;
+        this.requestOptions = requestOptions;
+    }
+}
+exports.default = RequestError;

package/dist/es/errors/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseErrorToReadableJson_1 = __importDefault(require("./parseErrorToReadableJson"));
+const RequestError_1 = __importDefault(require("./RequestError"));
+exports.default = {
+    parseErrorToReadableJson: parseErrorToReadableJson_1.default,
+    RequestError: RequestError_1.default
+};

package/dist/es/errors/parseErrorToReadableJson.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseErrorToReadableJson = (error) => JSON.parse(JSON.stringify(error, Object.getOwnPropertyNames(error)));
+exports.default = parseErrorToReadableJson;

package/dist/es/helpers/async/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parallelLimit_1 = __importDefault(require("./parallelLimit"));
+exports.default = {
+    parallelLimit: parallelLimit_1.default
+};

package/dist/es/helpers/async/parallelLimit.js

@@ -0,0 +1,33 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parallelLimit = (tasksQueue, simultaneousTaskRunningLimit, returnErrors = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const results = [];
+    const runTasks = (tasksIterator) => __awaiter(void 0, void 0, void 0, function* () {
+        for (const [index, task] of tasksIterator) {
+            try {
+                results[index] = yield task();
+            }
+            catch (error) {
+                if (returnErrors)
+                    results[index] = error;
+                else
+                    throw error;
+            }
+        }
+    });
+    const workers = new Array(simultaneousTaskRunningLimit)
+        .fill(tasksQueue.entries())
+        .map(runTasks);
+    yield Promise.allSettled(workers);
+    return results;
+});
+exports.default = parallelLimit;

package/dist/es/helpers/encodings/decodeBase64.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const decodeBase64 = (str) => str && Buffer.from(str, 'base64').toString('ascii');
+exports.default = decodeBase64;

package/dist/es/helpers/encodings/encodeBase64.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const encodeBase64 = (str) => str && Buffer.from(str).toString('base64');
+exports.default = encodeBase64;

package/dist/es/helpers/encodings/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const encodeBase64_1 = __importDefault(require("./encodeBase64"));
+const decodeBase64_1 = __importDefault(require("./decodeBase64"));
+exports.default = {
+    encodeBase64: encodeBase64_1.default,
+    decodeBase64: decodeBase64_1.default
+};

package/dist/es/helpers/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const time_1 = __importDefault(require("./time"));
+const json_1 = __importDefault(require("./json"));
+const encodings_1 = __importDefault(require("./encodings"));
+const async_1 = __importDefault(require("./async"));
+exports.default = Object.assign(Object.assign(Object.assign(Object.assign({}, time_1.default), json_1.default), encodings_1.default), async_1.default);

package/dist/es/helpers/json/and.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const and = (...[func, ...funcs]) => (x) => !!func(x) && (funcs.length ? !!and.apply(null, funcs)(x) : true);
+exports.default = and;

package/dist/es/helpers/json/filterObjectsContainingString.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fp_1 = require("lodash/fp");
+const filterObjectsContainingString = (0, fp_1.curry)((string, objs = []) => {
+    const modifiedSearchString = (0, fp_1.flow)((0, fp_1.replace)(/[^\w]/g, ''), fp_1.toLower)(string);
+    if (!modifiedSearchString)
+        return [];
+    return (0, fp_1.filter)((0, fp_1.flow)(JSON.stringify, (0, fp_1.replace)(/[^\w]/g, ''), fp_1.toLower, (0, fp_1.includes)(modifiedSearchString)), objs);
+});
+exports.default = filterObjectsContainingString;

package/dist/es/helpers/json/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const transpose2dArray_1 = __importDefault(require("./transpose2dArray"));
+const mapOverObject_1 = __importDefault(require("./mapOverObject"));
+const filterObjectsContainingString_1 = __importDefault(require("./filterObjectsContainingString"));
+const and_1 = __importDefault(require("./and"));
+const or_1 = __importDefault(require("./or"));
+exports.default = {
+    transpose2dArray: transpose2dArray_1.default,
+    mapOverObject: mapOverObject_1.default,
+    filterObjectsContainingString: filterObjectsContainingString_1.default,
+    and: and_1.default,
+    or: or_1.default
+};

package/dist/es/helpers/json/mapOverObject.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fp_1 = require("lodash/fp");
+const and_1 = __importDefault(require("./and"));
+/**
+ * Function to map over properties in an object.
+ * This allows for transformations on both the keys and values of each properties.
+ * This function also supports currying
+ *
+ * @param func - function that takes in `value` & `key' from each object property and
+ *   returns a new key and new value in an array of length 2
+ *   e.g. (value, key) => [newKey, newValue]
+ * @param obj - JSON object which we wish to map over the properties of
+ *   e.g. { key1: value1, key2: value2 }
+ * @returns - JSON object with the transformed keys and values for each property
+ *   e.g. { newKey1: newValue1, newKey2: newValue2 }
+ */
+const mapOverObject = (0, fp_1.curry)((func, obj) => obj && (0, fp_1.isPlainObject)(obj)
+    ? (0, fp_1.flow)(Object.entries, (0, fp_1.map)(([key, value]) => func(value, key)), (0, fp_1.filter)((0, and_1.default)((0, fp_1.negate)(fp_1.isEmpty), (0, fp_1.flow)(fp_1.size, (0, fp_1.eq)(2)))), Object.fromEntries)(obj)
+    : obj);
+exports.default = mapOverObject;

package/dist/es/helpers/json/or.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const or = (...[func, ...funcs]) => (x) => !!func(x) || (!!funcs.length && !!or.apply(null, funcs)(x));
+exports.default = or;

package/dist/es/helpers/json/transpose2dArray.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fp_1 = require("lodash/fp");
+const transpose2dArray = (twoDimensionalArray) => (0, fp_1.reduce)((agg, [key, value]) => [
+    [...agg[0], key],
+    [...agg[1], value]
+], [[], []], twoDimensionalArray);
+exports.default = transpose2dArray;

package/dist/es/helpers/time/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sleep_1 = __importDefault(require("./sleep"));
+const millisecondsToHoursMinutesAndSeconds_1 = __importDefault(require("./millisecondsToHoursMinutesAndSeconds"));
+exports.default = {
+    sleep: sleep_1.default,
+    millisecondsToHoursMinutesAndSeconds: millisecondsToHoursMinutesAndSeconds_1.default
+};

package/dist/es/helpers/time/millisecondsToHoursMinutesAndSeconds.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const millisecondsToHoursMinutesAndSeconds = (milliseconds = 0) => {
+    if (typeof milliseconds !== 'number' || isNaN(milliseconds)) {
+        throw new Error(`Cannot calculate Hours, Minutes, or Seconds from non-number input: \`${milliseconds}\``);
+    }
+    let remainingMilliseconds = milliseconds;
+    const seconds = Math.floor((remainingMilliseconds / 1000) % 60);
+    remainingMilliseconds -= seconds * 1000;
+    const minutes = Math.floor((remainingMilliseconds / 60000) % 60);
+    remainingMilliseconds -= minutes * 60000;
+    const hours = Math.floor(remainingMilliseconds / 3600000);
+    return ((hours ? `${hours} hours${minutes || seconds ? ', ' : ''}` : '') +
+        (minutes ? `${minutes} minutes${seconds ? ', ' : ''}` : '') +
+        (seconds ? `${seconds} seconds` : '') +
+        (!hours && !minutes && !seconds ? `${milliseconds}ms` : ''));
+};
+exports.default = millisecondsToHoursMinutesAndSeconds;

package/dist/es/helpers/time/sleep.js

@@ -0,0 +1,13 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sleep = (ms = 2000) => __awaiter(void 0, void 0, void 0, function* () { return new Promise((r) => setTimeout(r, ms)); });
+exports.default = sleep;

package/dist/es/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userOptions = exports.logging = exports.requests = exports.helpers = exports.errors = void 0;
+const errors_1 = __importDefault(require("./errors"));
+exports.errors = errors_1.default;
+const helpers_1 = __importDefault(require("./helpers"));
+exports.helpers = helpers_1.default;
+const requests_1 = __importDefault(require("./requests"));
+exports.requests = requests_1.default;
+const logging_1 = __importDefault(require("./logging"));
+exports.logging = logging_1.default;
+const user_options_1 = __importDefault(require("./user-options"));
+exports.userOptions = user_options_1.default;

package/dist/es/logging/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./logger");
+exports.default = { getLogger: logger_1.getLogger, setLogger: logger_1.setLogger };

package/dist/es/logging/logger.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = exports.setLogger = void 0;
+const fs_1 = __importDefault(require("fs"));
+const fp_1 = require("lodash/fp");
+const loggingLevels = ['info', 'debug', 'trace', 'warn', 'error', 'fatal'];
+const writeToDevRunnerResults = (loggingLevel) => (...content) => fs_1.default.appendFileSync('devRunnerResults.json', '\n' + JSON.stringify({ SOURCE: `Logger.${loggingLevel}`, content }, null, 2));
+let logger = (0, fp_1.flow)((0, fp_1.reduce)((agg, level) => (Object.assign(Object.assign({}, agg), { [level]: writeToDevRunnerResults(level) })), {}))(loggingLevels);
+const setLogger = (_logger) => {
+    logger = _logger;
+};
+exports.setLogger = setLogger;
+const getLogger = () => logger;
+exports.getLogger = getLogger;

package/dist/es/requests/createRequestWithDefaults.js

@@ -0,0 +1,166 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestWithDefaultsBuilder = void 0;
+const fs = require("fs");
+const postman_request_1 = __importDefault(require("postman-request"));
+const fp_1 = require("lodash/fp");
+const bottleneck_1 = __importDefault(require("bottleneck"));
+const logging_1 = __importDefault(require("../logging"));
+const errors_1 = __importDefault(require("../errors"));
+const _configFieldIsValid = (field) => typeof field === 'string' && field.length > 0;
+let limiter;
+function _setupLimiter(options) {
+    limiter = new bottleneck_1.default({
+        maxConcurrent: options.maxConcurrentRequests
+            ? Number.parseInt(options.maxConcurrentRequests, 10)
+            : 10,
+        highWater: 50,
+        strategy: bottleneck_1.default.strategy.OVERFLOW,
+        minTime: options.minimumMillisecondsRequestWillTake
+            ? Number.parseInt(options.minimumMillisecondsRequestWillTake, 10)
+            : 200
+    });
+}
+/**
+ * @param interface CreateRequestFunctionArguments {
+ *   config?: type ConfigJs = {
+ *     request: {
+ *       ca?: string;
+ *       cert?: string;
+ *       key?: string;
+ *       passphrase?: string;
+ *       rejectUnauthorized?: string;
+ *       proxy?: string;
+ *       json?: boolean;
+ *     };
+ *   } | undefined;
+ *     * The entire config.js(on) object
+ *   roundedSuccessStatusCode?: number[];
+ *     * Defaults: [200]
+ *     * Status codes, rounded to the 100's place, that should not throw errors.
+ *   useLimiter?: boolean;
+ *     * Defaults: false
+ *     * Set limit params in options (options.maxConcurrentRequests [default 10] & options.minimumMillisecondsRequestWillTake [default 200]) passed when
+ *       using the RequestWithDefaultsFunction this function returns
+ *       which can be hardcoded or can come from the userOptions directly
+ *   requestOptionsToOmitFromLogsKeyPaths?: string[];
+ *     * Defaults: ['headers.Authorization']
+ *     * Key Paths on the Request Options you wish to not automatically log.
+ *   preprocessRequestOptions?: type PreprocessRequestOptionsFunction =
+ *     (requestOptions: RequestOptions) => Promise<object> | never | undefined;
+ *   postprocessRequestResponse?: type PostprocessRequestResponseFunction =
+ *     (response: any, requestOptions: RequestOptions) => Promise<any> | never | undefined;
+ *   postprocessRequestFailure?: type PostprocessRequestFailureFunction =
+ *     (error: Error, requestOptions: RequestOptions) => Promise<any> | never | undefined;
+ * }
+ * @returns type RequestWithDefaultsFunction = (requestOptions: RequestOptions) => Promise<any> | never
+ *   * Returns an async request function with the proxy defaults included in the request options
+ *   * type RequestOptions = {
+ *       url?: string;
+ *       headers?: object;
+ *       qs?: object;
+ *       options?: object;
+ *       entity?: object;
+ *       form?: object;
+ *       [key: string]: any;
+ *    }
+};
+ */
+const createRequestWithDefaults = ({ config: { request: { ca, cert, key, passphrase, rejectUnauthorized, proxy, json } } = {
+    request: {
+        ca: '',
+        cert: '',
+        key: '',
+        passphrase: '',
+        proxy: '',
+        rejectUnauthorized: false,
+        json: true
+    }
+}, roundedSuccessStatusCodes = [200], useLimiter = false, requestOptionsToOmitFromLogsKeyPaths = ['headers.Authorization'], preprocessRequestOptions = (requestOptions) => __awaiter(void 0, void 0, void 0, function* () { return ({}); }), postprocessRequestResponse = (response, requestOptions) => __awaiter(void 0, void 0, void 0, function* () { return response; }), postprocessRequestFailure = (error, requestOptions) => __awaiter(void 0, void 0, void 0, function* () {
+    throw error;
+}) }) => {
+    const defaultsProxyOptions = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (_configFieldIsValid(ca) && { ca: fs.readFileSync(ca) })), (_configFieldIsValid(cert) && { cert: fs.readFileSync(cert) })), (_configFieldIsValid(key) && { key: fs.readFileSync(key) })), (_configFieldIsValid(passphrase) && { passphrase })), (_configFieldIsValid(proxy) && { proxy })), (typeof rejectUnauthorized === 'boolean' && { rejectUnauthorized })), { json });
+    const requestDefaultsWithInterceptors = (0, exports.requestWithDefaultsBuilder)(defaultsProxyOptions, roundedSuccessStatusCodes, useLimiter, requestOptionsToOmitFromLogsKeyPaths, preprocessRequestOptions, postprocessRequestResponse, postprocessRequestFailure);
+    return requestDefaultsWithInterceptors;
+};
+const requestWithDefaultsBuilder = (defaultsProxyOptions, roundedSuccessStatusCodes, useLimiter, requestOptionsToOmitFromLogsKeyPaths, preprocessRequestOptions, postprocessRequestResponse, postprocessRequestFailure) => {
+    const defaultsRequest = postman_request_1.default.defaults(defaultsProxyOptions);
+    const _requestWithDefaults = (requestOptions) => new Promise((resolve, reject) => {
+        defaultsRequest(requestOptions, (err, res) => {
+            if (err)
+                return reject(err);
+            resolve(res);
+        });
+    });
+    return (requestOptions) => __awaiter(void 0, void 0, void 0, function* () {
+        if (useLimiter && !limiter)
+            _setupLimiter(requestOptions.options);
+        const preRequestFunctionResults = yield preprocessRequestOptions(requestOptions);
+        const _requestOptions = Object.assign(Object.assign({}, requestOptions), preRequestFunctionResults);
+        let postRequestFunctionResults, result;
+        try {
+            result = yield (useLimiter
+                ? limiter.schedule(_requestWithDefaults, _requestOptions)
+                : _requestWithDefaults(_requestOptions));
+            checkForStatusError(result, _requestOptions, roundedSuccessStatusCodes, requestOptionsToOmitFromLogsKeyPaths);
+            postRequestFunctionResults = yield postprocessRequestResponse(result, _requestOptions);
+        }
+        catch (error) {
+            try {
+                postRequestFunctionResults = yield postprocessRequestFailure(error, _requestOptions);
+            }
+            catch (error) {
+                const err = errors_1.default.parseErrorToReadableJson(error);
+                if (useLimiter) {
+                    error.maxRequestQueueLimitHit =
+                        ((0, fp_1.isEmpty)(err) && (0, fp_1.isEmpty)(result)) ||
+                            (err &&
+                                (err.message ===
+                                    'This job has been dropped by Bottleneck for going over API Limits' ||
+                                    err instanceof bottleneck_1.default.BottleneckError));
+                    error.isConnectionReset =
+                        (0, fp_1.getOr)('', 'errors[0].meta.err.code', err) === 'ECONNRESET';
+                }
+                if (_requestOptions.entity)
+                    error.entity = JSON.stringify(_requestOptions.entity);
+                throw error;
+            }
+        }
+        return postRequestFunctionResults;
+    });
+};
+exports.requestWithDefaultsBuilder = requestWithDefaultsBuilder;
+const checkForStatusError = ({ statusCode, body }, requestOptions, roundedSuccessStatusCodes, requestOptionsToOmitFromLogsKeyPaths) => {
+    const Logger = logging_1.default.getLogger();
+    const requestOptionsWithoutSensitiveData = (0, fp_1.omit)(requestOptionsToOmitFromLogsKeyPaths.concat('options'), requestOptions);
+    Logger.trace({
+        MESSAGE: 'Request Ran, Checking Status...',
+        statusCode,
+        requestOptions: requestOptionsWithoutSensitiveData,
+        responseBody: body
+    });
+    const roundedStatus = Math.round(statusCode / 100) * 100;
+    const statusCodeNotSuccessful = !roundedSuccessStatusCodes.includes(roundedStatus);
+    const responseBodyError = (0, fp_1.get)('error', body);
+    if (statusCodeNotSuccessful || responseBodyError) {
+        const message = (0, fp_1.get)('message', responseBodyError);
+        const status = statusCodeNotSuccessful ? statusCode : (0, fp_1.get)('code', responseBodyError);
+        const description = JSON.stringify(body);
+        const requestOptions = JSON.stringify(requestOptionsWithoutSensitiveData);
+        const requestError = new errors_1.default.RequestError(message, status, description, requestOptions);
+        throw requestError;
+    }
+};
+exports.default = createRequestWithDefaults;

package/dist/es/requests/createRequestsInParallel.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fp_1 = require("lodash/fp");
+const helpers_1 = __importDefault(require("../helpers"));
+const createRequestsInParallel = (requestWithDefaults) => (allRequestsOptions, responseGetPath = 'body', possibleSimultaneousRequests = 10, returnErrors = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const unexecutedRequestFunctions = (0, fp_1.map)((_a) => {
+        var { entity } = _a, requestOptions = __rest(_a, ["entity"]);
+        return () => __awaiter(void 0, void 0, void 0, function* () {
+            const response = yield requestWithDefaults(requestOptions);
+            const result = responseGetPath ? (0, fp_1.get)(responseGetPath, response) : response;
+            return entity ? { entity, result } : result;
+        });
+    }, allRequestsOptions);
+    const results = yield helpers_1.default.parallelLimit(unexecutedRequestFunctions, possibleSimultaneousRequests, returnErrors);
+    return results;
+});
+exports.default = createRequestsInParallel;

package/dist/es/requests/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRequestWithDefaults_1 = __importDefault(require("./createRequestWithDefaults"));
+const createRequestsInParallel_1 = __importDefault(require("./createRequestsInParallel"));
+exports.default = {
+    createRequestWithDefaults: createRequestWithDefaults_1.default,
+    createRequestsInParallel: createRequestsInParallel_1.default
+};

package/dist/es/requests/requestTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es/user-options/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const validateUrlOption_1 = __importDefault(require("./validateUrlOption"));
+exports.default = {
+    validateUrlOption: validateUrlOption_1.default
+};

package/dist/es/user-options/validateUrlOption.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fp_1 = require("lodash/fp");
+/**
+ *
+ * @param {object} options - User Options from the inside of validate options
+ *   e.g. each user option contains a metadata object including the value
+ *   { userOption1: { value: 'user option input' ...moreOptionMetadata } }
+ * @param {string} urlKey - [ default='url' ] The key of the url inside of the user options
+ *   defined via the `./config/config.js(on)` `options.?.key` property value.
+ *   Generally if there is only 1 url user option, the `key` property should be set to
+ *   `url` so the default option here can be used. If there are more than 1 url in the
+ *   user options giving the `options.?.key` properties different value is expected.
+ * @param {array<objects>} otherValidationErrors - [ default=[] ] Allows you to pass in
+ *   existing validation error objects that will have any new validation errors found
+ *   added onto the end before returned.
+ *   [
+ *     {
+ *       key: 'otherUserOptionKey',
+ *       message: 'Description of something wrong with the users input for this user option.'
+ *     }
+ *   ]
+ *
+ * @returns {array<objects> || throws} Any URL based Validation Error found in relation to the user option
+ *   for the `urlKey` param found on the `options param
+ *   [
+ *     ...otherValidationErrors
+ *     {
+ *       key: 'url',
+ *       message: '* Required'
+ *     },
+ *     // OR
+ *     {
+ *       key: 'url',
+ *       message: 'Your Url must not end with a //'
+ *     },
+ *     // OR
+ *     {
+ *       key: 'url',
+ *       message: 'What is currently provided is not a valid URL. You must provide a valid Instance URL.'
+ *     },
+ *   ]
+ */
+const validateUrlOption = (options, urlKey = 'url', otherValidationErrors = []) => {
+    const urlValue = (0, fp_1.get)([urlKey, 'value'], options);
+    if (urlValue === undefined) {
+        throw new Error(`User Option key \`${urlKey}\` is not defined in the config.js.  ` +
+            "It's also possible you need to change the package.json version for the client to pick up your `config/config.js` changes.");
+    }
+    let allValidationErrors = otherValidationErrors;
+    // TODO: Add support & tests for non-required urls or remove the `required` input value check if the situation where desire for use of this feature is encountered
+    if (!urlValue) {
+        allValidationErrors = allValidationErrors.concat({
+            key: urlKey,
+            message: '* Required'
+        });
+    }
+    if (urlValue.endsWith('//')) {
+        allValidationErrors = allValidationErrors.concat({
+            key: urlKey,
+            message: 'Your Url must not end with a //'
+        });
+    }
+    if (urlValue) {
+        try {
+            new URL(urlValue);
+        }
+        catch (_) {
+            allValidationErrors = allValidationErrors.concat({
+                key: urlKey,
+                message: 'What is currently provided is not a valid URL. You must provide a valid Instance URL.'
+            });
+        }
+    }
+    return allValidationErrors;
+};
+exports.default = validateUrlOption;

package/dist/lib/errors/RequestError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RequestError extends Error {
+    constructor(message, status, description, requestOptions) {
+        super();
+        this.message = `Request Error${message ? ` -> ${message}` : ''}`;
+        this.status = status;
+        this.description = description;
+        this.requestOptions = requestOptions;
+    }
+}
+exports.default = RequestError;