@methodus/server
Version:
dynamic rpc components
187 lines • 7.43 kB
JavaScript
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
const response_1 = require("./response");
const log_1 = require("./log");
class Verbs {
}
Verbs.Get = 'GET';
Verbs.Post = 'POST';
Verbs.Put = 'PUT';
Verbs.Patch = 'PATCH';
Verbs.Head = 'HEAD';
Verbs.Delete = 'DELETE';
exports.Verbs = Verbs;
class RestResponse {
constructor(args, methodResult, headers) {
let res = args[1]; //in express this will ontain the response
if (methodResult && methodResult.statusCode) {
res.status(methodResult.statusCode);
}
else if (!methodResult || methodResult.error) {
res.status(500);
}
else {
res.status(200);
}
if (methodResult && !methodResult.error) {
if (methodResult.total)
res.set('X-Total-Count', methodResult.total);
if (methodResult.page)
res.set('X-Page', methodResult.page);
}
if (methodResult === null)
throw (new response_1.MethodError('null result from controller function', 500));
if (headers) {
Object.keys(headers).map((header) => {
res.setHeader(header, headers[header]);
});
}
//when we pipe the result using node streams we eed to pass inthe original headers for the response
if (methodResult && methodResult.result && methodResult.result.readable) {
if (methodResult.headers) {
Object.keys(methodResult.headers).forEach((key) => {
res.setHeader(key, methodResult.headers[key]);
});
}
methodResult.result.pipe(res).on('error', (err) => {
console.error('stream errored', err);
}).on('reponse', (response) => {
console.error('stream responsed', response);
}).on('finish', (response) => {
console.error('stream finished');
});
return;
}
if (methodResult.error) {
res.send(methodResult.error);
}
else if (methodResult.result && Buffer.isBuffer(methodResult.result)) {
res.end(methodResult.result);
}
else {
if (methodResult.result === 0) {
methodResult.result = JSON.stringify(methodResult.result);
}
if (typeof methodResult.result === 'string') {
res.end(methodResult.result, 'utf-8');
}
else {
res.set('Content-Type', 'application/json');
if (methodResult.result) {
res.end(JSON.stringify(methodResult.result), 'utf-8');
}
else {
res.end(JSON.stringify(methodResult), 'utf-8');
}
}
}
}
}
exports.RestResponse = RestResponse;
/** this function parses values from the request object into the function args
* @param {any} args - the arguments sent to the original function.
* @param {[string]} paramsMap - express route string.
*
*/
class RestParser {
constructor(args, paramsMap, functionArgs) {
this.args = args;
this.paramsMap = paramsMap;
this.functionArgs = functionArgs;
}
deserialize(item) {
if (item !== undefined && item !== null) {
if (item.type && item.type.deserialize) {
try {
return item.type.deserialize(item.value);
}
catch (error) {
log_1.logger.warn(this, 'error deserializing argument', item);
}
}
else if (item.type && item.type.prototype && item.type.prototype.constructor) {
return new item.type(item.value);
}
else if (typeof (item.value) === 'string' && item.type === 'object') {
try {
return JSON.parse(item.value);
}
catch (error) {
log_1.logger.warn(this, 'error parsing argument', item);
}
}
else if (item.value === undefined && typeof (item) === 'object') {
return item;
}
}
else {
return item;
}
return item.value;
}
parse() {
let isRest = false;
let context;
let securityContext;
if (this.args[0] && this.args[0].res && this.args[1] && this.args[1].req) {
securityContext = this.args[0].att || this.args[0].att_security_context;
this.functionArgs = [];
this.paramsMap.forEach((item) => {
if (item.name && item.from) {
item.value = this.args[0][item.from][item.name] || item.defaultValue || null;
item.value = this.deserialize(item);
}
else if (item.from) {
switch (item.from) {
case 'response':
item.value = this.args[1];
break;
case 'request':
item.value = this.args[0];
break;
default:
item.value = this.deserialize(this.args[0][item.from]);
break;
}
}
else {
item.value = this.args[0];
}
//security special case
if (item.from === 'att_security_context') {
item.value = this.args[0].att_security_context || this.args[0].att;
}
this.functionArgs.push(item.value);
});
isRest = true;
}
else {
this.functionArgs = this.args;
isRest = false;
}
return new ParserResponse(this.functionArgs, isRest, securityContext);
}
}
exports.RestParser = RestParser;
let ParserResponse = class ParserResponse {
constructor(args, isRest, securityContext) {
this.args = args;
this.isRest = isRest;
this.securityContext = securityContext;
}
};
ParserResponse = __decorate([
log_1.LogClass(log_1.logger),
__metadata("design:paramtypes", [Object, Boolean, Object])
], ParserResponse);
exports.ParserResponse = ParserResponse;
//# sourceMappingURL=rest.js.map