deep-resource
Version:
DEEP Resource Library
339 lines (272 loc) • 9.48 kB
JavaScript
/**
* Created by AlexanderC on 6/10/15.
*/
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.LambdaResponse = undefined;
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _Response2 = require('./Response');
var _ValidationError = require('./Exception/ValidationError');
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
/**
* Response object
*/
let LambdaResponse = exports.LambdaResponse = function (_Response) {
_inherits(LambdaResponse, _Response);
/**
* @param {*} args
*/
function LambdaResponse() {
var _ref;
_classCallCheck(this, LambdaResponse);
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
var _this = _possibleConstructorReturn(this, (_ref = LambdaResponse.__proto__ || Object.getPrototypeOf(LambdaResponse)).call.apply(_ref, [this].concat(args)));
_this._originalResponse = null;
_this._logResult = null;
// assure calling the very first!
_this._fillStatusCode();
let responsePayload = _this._decodePayload();
_this._fillData(responsePayload);
_this._fillError(responsePayload);
return _this;
}
/**
* @param {AWS.Response|null} response
*/
_createClass(LambdaResponse, [{
key: '_fillData',
/**
* @param {Object|null} responsePayload
* @private
*/
value: function _fillData(responsePayload) {
if (responsePayload && !this._request.async && !responsePayload.hasOwnProperty('errorMessage')) {
this._data = responsePayload;
}
}
/**
* @param {Object|null} responsePayload
* @private
*/
}, {
key: '_fillError',
value: function _fillError(responsePayload) {
if (this._rawError) {
this._error = this._rawError;
} else if (!this._request.async) {
if (responsePayload && responsePayload.hasOwnProperty('errorMessage')) {
this._error = LambdaResponse.getPayloadError(responsePayload);
}
} else if (this._statusCode !== 202) {
// check for failed async invocation
this._error = new Error('Unknown async invocation error');
}
}
/**
* @private
*/
}, {
key: '_fillStatusCode',
value: function _fillStatusCode() {
if (this._rawData) {
this._statusCode = parseInt(this._rawData.StatusCode || this._rawData.Status);
} else {
this._statusCode = 500;
}
}
/**
* @returns {Object|null}
* @private
*/
}, {
key: '_decodePayload',
value: function _decodePayload() {
let decodedPayload = null;
if (this._rawData) {
if (this._rawData.Payload) {
decodedPayload = LambdaResponse._decodePayloadObject(this._rawData.Payload);
// treat the case when error is stored in payload (nested)
if (decodedPayload && decodedPayload.hasOwnProperty('errorMessage')) {
decodedPayload = LambdaResponse._decodeRawErrorObject(decodedPayload.errorMessage);
}
} else if (this._rawData.errorMessage) {
decodedPayload = LambdaResponse._decodeRawErrorObject(this._rawData.errorMessage);
}
}
return decodedPayload;
}
/**
* @param {String|Object|*} rawError
* @returns {Object|String|null}
* @private
*/
}, {
key: '_decodeBase64',
/**
* @param {String} str
* @returns {String}
* @private
*/
value: function _decodeBase64(str) {
if (typeof Buffer !== 'undefined') {
str = new Buffer(str, 'base64').toString('utf8');
} else if (typeof atob !== 'undefined') {
str = atob(str);
}
return str;
}
}, {
key: 'originalResponse',
set: function set(response) {
this._originalResponse = response;
}
/**
*
* @returns {AWS.Response|null}
*/
,
get: function get() {
return this._originalResponse;
}
/**
* @returns {Object}
*/
}, {
key: 'headers',
get: function get() {
if (!this._headers && this.originalResponse) {
this._headers = this.originalResponse.httpResponse ? this.originalResponse.httpResponse.headers : {};
}
return this._headers;
}
/**
* @returns {String|null}
*/
}, {
key: 'requestId',
get: function get() {
if (!this._requestId && this.headers) {
if (this.headers[_Response2.Response.REQUEST_ID_HEADER.toLowerCase()]) {
this._requestId = this.headers[_Response2.Response.REQUEST_ID_HEADER.toLowerCase()];
}
}
return this._requestId;
}
}, {
key: 'logResult',
/**
* @returns {String}
*/
get: function get() {
if (this._logResult) {
return this._logResult;
}
if (this._rawData && this._rawData.hasOwnProperty('LogResult')) {
this._logResult = this._decodeBase64(this._rawData.LogResult);
}
return this._logResult;
}
/**
* @param {String} rawPayload
* @returns {Object|String|null}
* @private
*/
}], [{
key: '_decodeRawErrorObject',
value: function _decodeRawErrorObject(rawError) {
let errorObj = rawError;
if (typeof errorObj === 'string') {
try {
errorObj = JSON.parse(errorObj);
} catch (e) {
errorObj = {
errorMessage: errorObj, // assume errorObj is the error message
errorStack: new Error('Unknown error occurred.').stack,
errorType: 'UnknownError'
};
}
} else {
errorObj = errorObj || {
errorMessage: 'Unknown error occurred.',
errorStack: new Error('Unknown error occurred.').stack,
errorType: 'UnknownError'
};
}
return errorObj;
}
}, {
key: '_decodePayloadObject',
value: function _decodePayloadObject(rawPayload) {
let payload = rawPayload;
if (typeof rawPayload === 'string') {
try {
payload = JSON.parse(payload);
} catch (e) {
console.debug('Unable to parse: ', e);
}
}
return payload;
}
/**
* @param {Object} payload
* @returns {Error|ValidationError|null}
*/
}, {
key: 'getPayloadError',
value: function getPayloadError(payload) {
if (payload.hasOwnProperty('errorMessage')) {
let error = null;
if (LambdaResponse.isValidationError(payload)) {
error = new _ValidationError.ValidationError(payload.errorMessage, payload.validationErrors);
} else {
payload.errorType = payload.errorType || 'UnknownError';
payload.errorMessage = payload.errorMessage || 'Unknown error occurred.';
payload.errorStack = payload.errorStack || new Error(payload.errorMessage).stack;
error = new Error(payload.errorMessage);
// try to define a custom constructor name
// fail silently in case of readonly property...
try {
Object.defineProperty(error, 'name', {
value: payload.errorType
});
} catch (e) {
console.debug('Unable to define property: ', e);
}
}
try {
Object.defineProperty(error, 'stack', {
value: payload.errorStack
});
} catch (e) {
console.debug('Unable to define property: ', e);
}
return error;
}
return null;
}
/**
* @param {Object} payload
* @returns {Boolean}
*/
}, {
key: 'isValidationError',
value: function isValidationError(payload) {
return payload.hasOwnProperty('errorType') && payload.hasOwnProperty('errorMessage') && payload.hasOwnProperty('validationErrors') && payload.errorType === LambdaResponse.VALIDATION_ERROR_TYPE;
}
/**
* @returns {String}
*/
}, {
key: 'VALIDATION_ERROR_TYPE',
get: function get() {
return 'ValidationError';
}
}]);
return LambdaResponse;
}(_Response2.Response);