@barchart/common-js
Version:
Library of common JavaScript utilities
203 lines (197 loc) • 7.56 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var Gateway_exports = {};
__export(Gateway_exports, {
default: () => Gateway
});
module.exports = __toCommonJS(Gateway_exports);
var import_axios = __toESM(require("axios"));
var array = __toESM(require("./../../lang/array.js"));
var assert = __toESM(require("./../../lang/assert.js"));
var attributes = __toESM(require("./../../lang/attributes.js"));
var is = __toESM(require("./../../lang/is.js"));
var promise = __toESM(require("./../../lang/promise.js"));
var import_Endpoint = __toESM(require("./definitions/Endpoint.js"));
var import_VerbType = __toESM(require("./definitions/VerbType.js"));
var import_FailureReason = __toESM(require("./../failures/FailureReason.js"));
var import_FailureType = __toESM(require("./../failures/FailureType.js"));
class Gateway {
constructor() {
}
/**
* Invokes a web service endpoint, given the payload supplied.
*
* @public
* @static
* @async
* @param {Endpoint} endpoint
* @param {*=} payload
* @returns {Promise<object>}
*/
static async invoke(endpoint, payload) {
assert.argumentIsRequired(endpoint, "endpoint", import_Endpoint.default, "Endpoint");
const pathParameters = endpoint.path.parameters;
const headerParameters = endpoint.headers.parameters;
const queryParameters = endpoint.query.parameters;
const bodyParameters = endpoint.body.parameters;
const extractParameter = async (parameter) => {
try {
const value = await parameter.extractor(payload);
return value;
} catch {
return null;
}
};
const groups = await Promise.all([
promise.map(pathParameters, extractParameter),
promise.map(headerParameters, extractParameter),
promise.map(queryParameters, extractParameter),
promise.map(bodyParameters, extractParameter)
]);
const pathValues = groups[0];
const headerValues = groups[1];
const queryValues = groups[2];
const bodyValues = groups[3];
const parameters = array.flatten([pathParameters, headerParameters, queryParameters, bodyParameters]);
const values = array.flatten([pathValues, headerValues, queryValues, bodyValues]);
const failure = values.reduce((accumulator, value, index) => {
let updatedFailure = accumulator;
const parameter = parameters[index];
if (value === null && !parameter.optional) {
if (accumulator === null) {
updatedFailure = import_FailureReason.default.forRequest({ endpoint }).addItem(import_FailureType.default.REQUEST_CONSTRUCTION_FAILURE, null, true);
}
updatedFailure.addItem(import_FailureType.default.REQUEST_PARAMETER_MISSING, { name: parameter.description });
}
return updatedFailure;
}, null);
if (failure !== null) {
throw failure.format();
}
const options = {};
const url = [];
url.push(endpoint.protocol.prefix);
url.push(endpoint.host);
if (endpoint.port !== endpoint.protocol.defaultPort) {
url.push(":");
url.push(endpoint.port);
}
url.push("/");
const paths = await promise.pipeline(pathValues.map((value) => (previous) => {
let encodedValue;
if (is.nil(value) || is.undef(value)) {
encodedValue = value;
} else {
encodedValue = value.toString().replace(/\//g, "%2F");
}
previous.push(encodedValue);
return previous;
}), []);
url.push(paths.join("/"));
options.method = verbs.get(endpoint.verb);
options.url = url.join("");
if (headerParameters.length !== 0) {
const headers = await promise.pipeline(headerValues.map((value, i) => (accumulator) => {
const parameter = headerParameters[i];
accumulator[parameter.key] = value;
return accumulator;
}), {});
if (headers.length !== 0) {
options.headers = headers;
}
}
if (queryParameters.length !== 0) {
const query = await promise.pipeline(queryValues.map((value, i) => (accumulator) => {
const parameter = queryParameters[i];
accumulator[parameter.key] = value;
return accumulator;
}), {});
if (query.length !== 0) {
options.params = query;
}
}
if (bodyParameters.length !== 0) {
const body = await promise.pipeline(bodyValues.map((value, i) => (accumulator) => {
const parameter = bodyParameters[i];
attributes.write(accumulator, parameter.key, value);
return accumulator;
}), {});
options.data = body.body;
}
if (endpoint.credentials) {
const credentials = await Promise.all([
endpoint.credentials.usernameExtractor(payload),
endpoint.credentials.passwordExtractor(payload)
]);
options.auth = {
username: credentials[0],
password: credentials[1]
};
}
const request = endpoint.requestInterceptor ? await endpoint.requestInterceptor.process(options, endpoint) : options;
try {
const response = await import_axios.default.request(request);
if (endpoint.responseInterceptor) {
return endpoint.responseInterceptor.process(response, endpoint);
}
return response;
} catch (error) {
if (endpoint.errorInterceptor) {
return endpoint.errorInterceptor.process(error, endpoint);
}
throw error;
}
}
/**
* Returns a string representation.
*
* @public
* @returns {string}
*/
toString() {
return "[Gateway]";
}
}
const verbs = /* @__PURE__ */ new Map();
verbs.set(import_VerbType.default.GET, "get");
verbs.set(import_VerbType.default.DELETE, "delete");
verbs.set(import_VerbType.default.POST, "post");
verbs.set(import_VerbType.default.PUT, "put");
verbs.set(import_VerbType.default.PATCH, "patch");
{
const cjsExports = module.exports;
const cjsDefaultExport = cjsExports && cjsExports.__esModule ? cjsExports.default : cjsExports;
if (cjsDefaultExport && (typeof cjsDefaultExport === 'function' || typeof cjsDefaultExport === 'object')) {
Object.keys(cjsExports).forEach((key) => {
if (key !== 'default' && key !== '__esModule') {
cjsDefaultExport[key] = cjsExports[key];
}
});
}
module.exports = cjsDefaultExport;
}