@methodus/platform-rest
Version:
REST plugin for methodus
366 lines • 15.9 kB
JavaScript
;
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 __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.WebRequest = void 0;
require("reflect-metadata");
var axios_1 = require("axios");
var https = require("https");
var fs = require("fs");
var path = require("path");
var tunnel = require("tunnel");
var encoder_1 = require("./encoder");
var framework_commons_1 = require("@methodus/framework-commons");
var logger = new framework_commons_1.default.Logger('transports:http');
var WebRequest = (function () {
function WebRequest() {
}
WebRequest.prototype.sendRequest = function (methodus, uri, params, paramsMap, securityContext) {
return __awaiter(this, void 0, void 0, function () {
var auth, authOptions, verb, body, headers, query, files, parts, payload, requestOptions, _a, _b, _c;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
auth = methodus._auth.type || framework_commons_1.AuthType.None;
authOptions = methodus._auth.options;
verb = methodus.verb;
body = {};
headers = {};
query = {};
files = [];
parts = uri.split('://')[1].split('/');
parts.splice(0, 1);
payload = handleParamsMap(paramsMap, {
auth: auth,
authOptions: authOptions,
params: params,
uri: uri,
body: body,
query: query,
headers: headers,
files: files,
verb: verb,
parts: parts,
});
handleQuery(payload);
requestOptions = {
method: verb.toLowerCase(),
url: payload.uri,
timeout: 1000 * 60 * 5,
};
Object.assign(requestOptions, handleProxy(requestOptions, payload));
Object.assign(requestOptions, handleHeaders(requestOptions, payload));
Object.assign(requestOptions, handleFiles(requestOptions, payload));
_b = (_a = Object).assign;
_c = [requestOptions];
return [4, handleAuth.apply(this, [requestOptions, payload, this])];
case 1:
_b.apply(_a, _c.concat([_d.sent()]));
logger.debug('Request options are: ', JSON.stringify(requestOptions));
return [2, requestOptions];
}
});
});
};
WebRequest.prototype.send = function (requestOptions) {
return __awaiter(this, void 0, void 0, function () {
var error_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 3]);
return [4, axios_1.default.request(requestOptions)];
case 1: return [2, _a.sent()];
case 2:
error_1 = _a.sent();
logger.error(error_1);
throw error_1;
case 3: return [2];
}
});
});
};
return WebRequest;
}());
exports.WebRequest = WebRequest;
function handleParamsMap(paramsMap, payload) {
paramsMap.forEach(function (item) {
item.value = payload.params[item.index];
switch (item.from) {
case 'params':
if (item.name) {
payload.uri = payload.uri.replace(':' + item.name, item.value);
}
else {
Object.keys(item.value).forEach(function (element) {
payload.uri = payload.uri.replace(':' + element, item.value[element]);
});
}
break;
case 'body':
if (item.name) {
payload.body[item.name] = item.value;
}
else {
if (typeof item.value === 'object' && !Array.isArray(item.value)) {
Object.assign(payload.body, item.value);
}
else {
payload.body = item.value;
}
}
break;
case 'query':
if (item.name) {
payload.query[item.name] = item.value;
}
else {
Object.assign(payload.query, item.value);
}
break;
case 'security_context':
payload.securityContext = {
uid: item.value.uid,
user_id: item.value.user_id,
};
break;
case 'headers':
if (item.name) {
payload.headers[item.name] = item.value;
}
else {
Object.assign(payload.headers, item.value);
}
break;
case 'files':
if (item.name) {
payload.files[item.name] = item.value;
}
else {
Object.assign(payload.files, item.value);
}
break;
}
});
return payload;
}
function handleQuery(payload) {
if (Object.keys(payload.query).length > 0) {
payload.uri +=
'?' +
Object.keys(payload.query)
.map(function (element) {
if (Array.isArray(payload.query[element])) {
return payload.query[element]
.map(function (subelement) {
if (typeof subelement !== 'string') {
return element + "=" + encodeURIComponent(JSON.stringify(subelement));
}
else {
return element + "=" + encodeURIComponent(subelement);
}
})
.join('&');
}
if (payload.query[element] && payload.query[element].toISOString) {
return element + "=" + encodeURIComponent(payload.query[element].toISOString());
}
else if (typeof payload.query[element] !== 'string') {
return element + "=" + encodeURIComponent(JSON.stringify(payload.query[element]));
}
else {
return element + "=" + encodeURIComponent(payload.query[element]);
}
})
.join('&');
}
return payload;
}
function handleProxy(requestOptions, payload) {
var mixedProtocolProxySettings = false;
if (process.env.METHODUS_PROXY) {
if (payload.uri.indexOf('https://') === 0 && process.env.METHODUS_PROXY_PORT !== '443') {
mixedProtocolProxySettings = true;
}
Object.assign(requestOptions, {
proxy: {
host: process.env.PROXY,
port: process.env.PROXY_PORT,
},
});
}
if (payload.uri.indexOf('https://') === 0) {
var hostParts = payload.uri.split('://')[1].split('/')[0].split(':');
var sslPort = hostParts[1] ? Number(hostParts[1]) : 443;
var agent = void 0;
if (!mixedProtocolProxySettings) {
agent = new https.Agent({
host: hostParts[0],
port: sslPort,
path: payload.parts.join('/').split('?')[0] || '',
rejectUnauthorized: false,
});
Object.assign(requestOptions, { httpsAgent: agent });
}
else {
agent = tunnel.httpsOverHttp({
proxy: {
host: process.env.METHODUS_PROXY,
port: Number(process.env.METHODUS_PROXY_PORT),
},
});
Object.assign(requestOptions, { httpsAgent: agent, proxy: false });
}
}
else {
requestOptions = {
method: payload.verb.toLowerCase(),
url: payload.uri,
timeout: 1000 * 60 * 5,
};
if (process.env.METHODUS_PROXY && process.env.METHODUS_PROXY_PORT) {
Object.assign(requestOptions, { proxy: { host: process.env.METHODUS_PROXY, port: process.env.METHODUS_PROXY_PORT } });
}
}
return requestOptions;
}
function handleAuth(requestOptions, payload, that) {
return __awaiter(this, void 0, void 0, function () {
var _a, _b, _c, base64HEader, _d, _e;
return __generator(this, function (_f) {
switch (_f.label) {
case 0:
if (!payload.auth) return [3, 9];
logger.log("Auth is " + JSON.stringify(payload.auth));
_a = payload.auth;
switch (_a) {
case framework_commons_1.AuthType.Basic: return [3, 1];
case framework_commons_1.AuthType.BearerToken: return [3, 5];
}
return [3, 9];
case 1:
requestOptions.headers = requestOptions.headers || {};
if (!(typeof payload.authOptions === 'function')) return [3, 3];
_b = requestOptions.headers;
_c = 'Authorization';
return [4, payload.authOptions.apply(this, [requestOptions])];
case 2:
_b[_c] = _f.sent();
return [3, 4];
case 3:
if (payload.authOptions.user && payload.authOptions.password) {
base64HEader = encoder_1.Encoder.encodeBase64(payload.authOptions.user + ":" + payload.authOptions.password);
requestOptions.headers['Authorization'] = "Basic " + base64HEader;
}
else if (payload.authOptions.token) {
requestOptions.headers['Authorization'] = "Basic " + payload.authOptions.token;
}
_f.label = 4;
case 4: return [3, 9];
case 5:
requestOptions.headers = requestOptions.headers || {};
if (!(typeof payload.authOptions === 'function')) return [3, 7];
_d = requestOptions.headers;
_e = 'Authorization';
return [4, payload.authOptions.apply(that, [requestOptions])];
case 6:
_d[_e] = _f.sent();
return [3, 8];
case 7:
requestOptions.headers['Authorization'] = payload.authOptions.token;
_f.label = 8;
case 8: return [3, 9];
case 9: return [2, requestOptions];
}
});
});
}
function handleFiles(requestOptions, payload) {
if (payload.files && payload.files.length > 0) {
var file = payload.files[0];
var formData = {
custom_file: {
value: fs.createReadStream(path.resolve(file.path)),
options: {
filename: file.originalname,
contentType: file.mimetype,
size: file.size,
},
},
};
Object.assign(requestOptions.data, formData);
}
else if (payload.files && payload.files.readable) {
var formData = {
custom_file: {
value: payload.files,
options: {
filename: path.basename(payload.files.path),
},
},
};
requestOptions.data = formData;
Object.assign(requestOptions.data, formData);
}
return requestOptions;
}
function handleHeaders(requestOptions, payload) {
requestOptions.headers = {};
if (typeof payload.body === 'object') {
if (Object.keys(payload.body).length) {
requestOptions.data = payload.body;
requestOptions.headers['Content-Type'] = 'application/json';
}
}
else if (payload.body.length) {
requestOptions.data = payload.body;
requestOptions.headers['Content-Type'] = 'application/xml';
}
if (payload.securityContext) {
Object.assign(requestOptions.headers, {
security_context: JSON.stringify(payload.securityContext),
});
}
if (payload.headers && Object.keys(payload.headers).length > 0) {
if (!requestOptions.headers) {
requestOptions.headers = {};
}
Object.assign(requestOptions.headers, payload.headers);
}
return requestOptions;
}
//# sourceMappingURL=web-request.js.map