paw-base-importer
Version:
An adapter for api-flow made for the Paw App
896 lines (744 loc) • 32.1 kB
JavaScript
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = undefined;
var _stringify = require('babel-runtime/core-js/json/stringify');
var _stringify2 = _interopRequireDefault(_stringify);
var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
var _getIterator2 = require('babel-runtime/core-js/get-iterator');
var _getIterator3 = _interopRequireDefault(_getIterator2);
var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
var _createClass2 = require('babel-runtime/helpers/createClass');
var _createClass3 = _interopRequireDefault(_createClass2);
var _class, _temp;
var _apiFlow = require('api-flow');
var _apiFlow2 = _interopRequireDefault(_apiFlow);
var _PawShims = require('../paw-mocks/PawShims');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var BaseImporter = (_temp = _class = function () {
function BaseImporter() {
(0, _classCallCheck3.default)(this, BaseImporter);
this.ENVIRONMENT_DOMAIN_NAME = 'Imported Environments';
this.context = null;
}
/*
@params:
- context
- string
*/
(0, _createClass3.default)(BaseImporter, [{
key: 'createRequestContextFromString',
value: function createRequestContextFromString(context, string) {
return this.createRequestContext(context, { content: string }, {});
}
// @not tested
}, {
key: 'importString',
value: function importString(context, string) {
var requestContext = this.createRequestContextFromString(context, string);
if (!(requestContext instanceof _apiFlow2.default)) {
throw new Error('createRequestContextFromString ' + 'did not return an instance of RequestContext');
}
this._importPawRequests(requestContext);
return true;
}
/*
@params:
- requestContexts
- context
- items
- options
*/
}, {
key: 'createRequestContext',
value: function createRequestContext() {
throw new Error('BaseImporter is an abstract class');
}
// @tested 70%
}, {
key: 'import',
value: function _import(context, items, options) {
var requestContexts = [];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = (0, _getIterator3.default)(items), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var item = _step.value;
requestContexts = this.createRequestContext(requestContexts, context, item, options);
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
this.context = context;
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = (0, _getIterator3.default)(requestContexts), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var env = _step2.value;
var requestContext = env.context;
if (!(requestContext instanceof _apiFlow2.default)) {
throw new Error('createRequestContext ' + 'did not return an instance of RequestContext');
}
this._importPawRequests(requestContext, env.items[0], options);
if (options && options.order) {
options.order += 1;
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
return true;
}
// @not tested
}, {
key: '_importPawRequests',
value: function _importPawRequests(requestContext, item, options) {
var _this = this;
var group = requestContext.get('group');
var schema = requestContext.get('schema');
var environments = requestContext.get('environments');
if (environments && environments.size > 0) {
this._importEnvironments(environments);
}
if (group.get('children').size === 0) {
return;
}
var parent = void 0;
var name = void 0;
if (group.get('name')) {
name = group.get('name');
} else if (item && item.file) {
name = item.file.name;
} else if (item && item.url) {
name = item.url;
}
parent = this.context.createRequestGroup(name);
if (options && options.parent) {
options.parent.appendChild(parent);
}
if (options && options.order !== null && typeof options.order !== 'undefined') {
parent.order = options.order;
}
var manageRequestGroups = function manageRequestGroups(current, parentGroup) {
if (current === parentGroup.name || current === '') {
return parentGroup;
}
var pawGroup = _this.context.createRequestGroup(current);
parentGroup.appendChild(pawGroup);
return pawGroup;
};
this._applyFuncOverGroupTree(group, function (request, requestParent) {
_this._importPawRequest.call(_this, options, requestParent, request, schema);
}, manageRequestGroups, parent);
}
// @tested
}, {
key: '_importEnvironments',
value: function _importEnvironments(environments) {
var environmentDomain = this._getEnvironmentDomain();
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
var _loop = function _loop() {
var env = _step3.value;
var pawEnv = environmentDomain.createEnvironment(env.name);
var variablesDict = {};
env.get('variables').forEach(function (value) {
variablesDict[value.get('key')] = value.get('value');
});
pawEnv.setVariablesValues(variablesDict);
};
for (var _iterator3 = (0, _getIterator3.default)(environments), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
_loop();
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
}
// @tested
}, {
key: '_getEnvironmentDomain',
value: function _getEnvironmentDomain() {
var env = this.context.getEnvironmentDomainByName(this.ENVIRONMENT_DOMAIN_NAME);
if (typeof env === 'undefined') {
env = this.context.createEnvironmentDomain(this.ENVIRONMENT_DOMAIN_NAME);
}
return env;
}
// @tested
}, {
key: '_getEnvironment',
value: function _getEnvironment(domain) {
var environmentName = arguments.length <= 1 || arguments[1] === undefined ? 'Default Environment' : arguments[1];
var env = domain.getEnvironmentByName(environmentName);
if (typeof env === 'undefined') {
env = domain.createEnvironment(environmentName);
}
return env;
}
// @tested
}, {
key: '_getEnvironmentVariable',
value: function _getEnvironmentVariable(name) {
var domain = this._getEnvironmentDomain();
var variable = domain.getVariableByName(name);
if (typeof variable === 'undefined') {
var env = this._getEnvironment(domain);
var varD = {};
varD[name] = '';
env.setVariablesValues(varD);
variable = domain.getVariableByName(name);
}
return variable;
}
// @tested 80%
}, {
key: '_importPawRequest',
value: function _importPawRequest(options, parent, request, schema) {
var headers = request.get('headers');
var auth = request.get('auth');
var bodyType = request.get('bodyType');
var body = request.get('body');
var timeout = request.get('timeout');
// url + method
var pawRequest = this._createPawRequest(request);
pawRequest.description = request.get('description');
// headers
pawRequest = this._setHeaders(pawRequest, headers);
// auth
pawRequest = this._setAuth.call(this, pawRequest, auth);
// body
pawRequest = this._setBody(pawRequest, bodyType, body, schema);
// timeout
if (timeout) {
pawRequest.timeout = timeout * 1000;
}
parent.appendChild(pawRequest);
// order
if (options && options.order) {
pawRequest.order = options.order;
}
return pawRequest;
}
// @tested
}, {
key: '_applyFuncOverGroupTree',
value: function _applyFuncOverGroupTree(group, leafFunc, nodeFunc, pawGroup) {
var _this2 = this;
var calls = [];
var currentPawGroup = nodeFunc(group.get('name') || '', pawGroup);
group.get('children').forEach(function (child) {
if (child instanceof _apiFlow.Request) {
calls.push(leafFunc(child, currentPawGroup));
} else {
calls = calls.concat(_this2._applyFuncOverGroupTree(child, leafFunc, nodeFunc, currentPawGroup));
}
});
return calls;
}
// @tested
}, {
key: '_createPawRequest',
value: function _createPawRequest(request) {
var url = this._generateUrl.call(this, request.get('url'), request.get('queries'), request.get('auth'));
return this.context.createRequest(request.get('name'), request.get('method'), url);
}
// @tested 70% (encodeURI behavior not tested)
}, {
key: '_generateUrl',
value: function _generateUrl(url, queries, auths) {
var _this3 = this;
var _url = this._toDynamicString(url, true, true);
var queryParams = (queries || []).concat(this._extractQueryParamsFromAuth(auths));
if (queryParams.size > 0) {
_url.appendString('?');
var _params = queryParams.reduce(function (params, keyValue) {
var dynKey = _this3._toDynamicString(keyValue.get('key'), true, true).components.map(function (component) {
if (typeof component === 'string') {
return encodeURI(component);
}
return component;
});
var dynValue = _this3._toDynamicString(keyValue.get('value'), true, true).components.map(function (component) {
if (typeof component === 'string') {
return encodeURI(component);
}
return component;
});
var param = [];
if (params.length !== 0) {
param.push('&');
}
param = param.concat(dynKey);
param.push('=');
param = param.concat(dynValue);
return params.concat(param);
}, []);
_url = new (Function.prototype.bind.apply(_PawShims.DynamicString, [null].concat((0, _toConsumableArray3.default)(_url.components), (0, _toConsumableArray3.default)(_params))))();
}
return _url;
}
// @tested
}, {
key: '_extractQueryParamsFromAuth',
value: function _extractQueryParamsFromAuth(auths) {
return (auths || []).filter(function (auth) {
return auth instanceof _apiFlow.Auth.ApiKey && auth.get('in') === 'query';
}).map(function (auth) {
return new _apiFlow.KeyValue({
key: auth.get('name'),
value: auth.get('key')
});
}).toArray();
}
// @tested
}, {
key: '_setHeaders',
value: function _setHeaders(pawReq, headers) {
var _this4 = this;
headers.forEach(function (value, key) {
pawReq.setHeader(_this4._toDynamicString(key, true, true), _this4._toDynamicString(value, true, true));
});
return pawReq;
}
// @tested
}, {
key: '_setBasicAuth',
value: function _setBasicAuth(auth) {
return new _PawShims.DynamicValue('com.luckymarmot.BasicAuthDynamicValue', {
username: this._toDynamicString(auth.get('username') || '', true, true),
password: this._toDynamicString(auth.get('password') || '', true, true)
});
}
// @tested
}, {
key: '_setDigestAuth',
value: function _setDigestAuth(auth) {
return new _PawShims.DynamicValue('com.luckymarmot.PawExtensions.DigestAuthDynamicValue', {
username: this._toDynamicString(auth.get('username'), true, true),
password: this._toDynamicString(auth.get('password'), true, true)
});
}
// @tested
}, {
key: '_setOAuth1Auth',
value: function _setOAuth1Auth(auth) {
return new _PawShims.DynamicValue('com.luckymarmot.OAuth1HeaderDynamicValue', {
callback: this._toDynamicString(auth.get('callback') || '', true, true),
consumerKey: this._toDynamicString(auth.get('consumerKey') || '', true, true),
consumerSecret: this._toDynamicString(auth.get('consumerSecret') || '', true, true),
tokenSecret: this._toDynamicString(auth.get('tokenSecret') || '', true, true),
algorithm: auth.get('algorithm') || '',
nonce: this._toDynamicString(auth.get('nonce') || '', true, true),
additionalParamaters: auth.get('additionalParamaters') || '',
timestamp: this._toDynamicString(auth.get('timestamp') || '', true, true),
token: this._toDynamicString(auth.get('token') || '', true, true)
});
}
// @tested
}, {
key: '_setOAuth2Auth',
value: function _setOAuth2Auth(auth) {
var grantMap = {
accessCode: 0,
implicit: 1,
application: 2,
password: 3
};
return new _PawShims.DynamicValue('com.luckymarmot.OAuth2DynamicValue', {
grantType: grantMap[auth.get('flow')] || 0,
authorizationUrl: this._toDynamicString(auth.get('authorizationUrl') || '', true, true),
accessTokenUrl: this._toDynamicString(auth.get('tokenUrl') || '', true, true),
scope: (auth.get('scopes') || []).join(' ')
});
}
// @tested
}, {
key: '_setAWSSig4Auth',
value: function _setAWSSig4Auth(auth) {
return new _PawShims.DynamicValue('com.shigeoka.PawExtensions.AWSSignature4DynamicValue', {
key: this._toDynamicString(auth.get('key') || '', true, true),
secret: this._toDynamicString(auth.get('secret') || '', true, true),
region: this._toDynamicString(auth.get('region') || '', true, true),
service: this._toDynamicString(auth.get('service') || '', true, true)
});
}
// @tested
}, {
key: '_setHawkAuth',
value: function _setHawkAuth(auth) {
return new _PawShims.DynamicValue('uk.co.jalada.PawExtensions.HawkDynamicValue', {
key: this._toDynamicString(auth.get('key') || '', true, true),
id: this._toDynamicString(auth.get('id') || '', true, true),
algorithm: this._toDynamicString(auth.get('algorithm') || '', true, true)
});
}
// @tested
}, {
key: '_setAuth',
value: function _setAuth(pawReq, auths) {
var authTypeMap = {
BasicAuth: this._setBasicAuth.bind(this),
DigestAuth: this._setDigestAuth.bind(this),
OAuth1Auth: this._setOAuth1Auth.bind(this),
OAuth2Auth: this._setOAuth2Auth.bind(this),
AWSSig4Auth: this._setAWSSig4Auth.bind(this),
HawkAuth: this._setHawkAuth.bind(this)
};
var _iteratorNormalCompletion4 = true;
var _didIteratorError4 = false;
var _iteratorError4 = undefined;
try {
for (var _iterator4 = (0, _getIterator3.default)(auths), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
var auth = _step4.value;
var rule = authTypeMap[auth.constructor.name];
if (rule) {
var dv = rule(auth);
pawReq.setHeader('Authorization', new _PawShims.DynamicString(dv));
} else if (auth instanceof _apiFlow.Auth.ApiKey) {
if (auth.get('in') === 'header') {
pawReq.setHeader(this._toDynamicString(auth.get('name'), true, true), this._toDynamicString(auth.get('key'), true, true));
}
} else {
/* eslint-disable no-console */
console.error('Auth type ' + auth.constructor.name + ' is not supported in Paw');
/* eslint-enable no-console */
}
}
} catch (err) {
_didIteratorError4 = true;
_iteratorError4 = err;
} finally {
try {
if (!_iteratorNormalCompletion4 && _iterator4.return) {
_iterator4.return();
}
} finally {
if (_didIteratorError4) {
throw _iteratorError4;
}
}
}
return pawReq;
}
// @tested
}, {
key: '_setBody',
value: function _setBody(pawReq, bodyType, body, _schema) {
var _this5 = this;
var bodyRules = {
formData: this._setFormDataBody.bind(this),
urlEncoded: this._setUrlEncodedBody.bind(this),
json: this._setJSONBody.bind(this),
plain: this._setPlainBody.bind(this),
file: this._setPlainBody.bind(this),
schema: function schema(_pawReq, _body) {
return _this5._setSchemaBody.call(_this5, _pawReq, _body, _schema);
},
null: function _null(_pawReq) {
return _pawReq;
}
};
var _pawReq = pawReq;
var rule = bodyRules[bodyType];
if (rule) {
_pawReq = rule(pawReq, body);
} else {
/* eslint-disable no-console */
console.error('Body type ' + bodyType + ' is not supported in Paw');
/* eslint-enable no-console */
}
return _pawReq;
}
// @tested
}, {
key: '_setFormDataBody',
value: function _setFormDataBody(pawReq, body) {
var keyValues = [];
var _iteratorNormalCompletion5 = true;
var _didIteratorError5 = false;
var _iteratorError5 = undefined;
try {
for (var _iterator5 = (0, _getIterator3.default)(body), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
var keyValue = _step5.value;
keyValues.push([this._toDynamicString(keyValue.get('key'), true, true), this._toDynamicString(keyValue.get('value'), true, true), true]);
}
} catch (err) {
_didIteratorError5 = true;
_iteratorError5 = err;
} finally {
try {
if (!_iteratorNormalCompletion5 && _iterator5.return) {
_iterator5.return();
}
} finally {
if (_didIteratorError5) {
throw _iteratorError5;
}
}
}
var dv = new _PawShims.DynamicValue('com.luckymarmot.BodyMultipartFormDataDynamicValue', {
keyValues: keyValues
});
pawReq.body = new _PawShims.DynamicString(dv);
return pawReq;
}
// @tested
}, {
key: '_setPlainBody',
value: function _setPlainBody(pawReq, body) {
pawReq.body = body || '';
return pawReq;
}
// @tested
}, {
key: '_setJSONBody',
value: function _setJSONBody(pawReq, body) {
if (typeof body === 'string') {
try {
pawReq.jsonBody = JSON.parse(body);
} catch (e) {
/* eslint-disable no-console */
console.error('body was set to JSON, but we couldn\'t parse it');
/* eslint-enable no-console */
pawReq.body = body;
}
} else {
pawReq.jsonBody = body;
}
return pawReq;
}
// @tested
}, {
key: '_setSchemaBody',
value: function _setSchemaBody(pawReq, body, schema) {
var _pawReq = pawReq;
_pawReq.description = (_pawReq.description ? _pawReq.description + '\n\n' : '') + '### Schema ###\n\n' + (0, _stringify2.default)(body.resolve(1, schema).toJS(), null, ' ');
return _pawReq;
}
// @tested
}, {
key: '_setUrlEncodedBody',
value: function _setUrlEncodedBody(pawReq, body) {
var _this6 = this;
var keyValues = body.map(function (keyValue) {
var key = _this6._toDynamicString(keyValue.get('key'), true, true);
var value = _this6._toDynamicString(keyValue.get('value'), true, true);
return [key, value, true];
}).toArray();
var dv = new _PawShims.DynamicValue('com.luckymarmot.BodyFormKeyValueDynamicValue', {
keyValues: keyValues
});
pawReq.body = new _PawShims.DynamicString(dv);
return pawReq;
}
// @tested
}, {
key: '_toDynamicString',
value: function _toDynamicString(string, defaultToEmpty, resolveFileRefs) {
if (!string) {
if (defaultToEmpty) {
return new _PawShims.DynamicString('');
}
return null;
}
// resolve file references
if (resolveFileRefs) {
var resolvedString = this._resolveFileReference(string);
if (typeof resolvedString !== 'string' && resolvedString instanceof _PawShims.DynamicString) {
return resolvedString;
}
}
var envComponents = [];
if (typeof string !== 'string' && string instanceof _apiFlow.EnvironmentReference) {
envComponents = this._castReferenceToDynamicString(string).components;
} else {
envComponents.push(string);
}
var components = [];
var _iteratorNormalCompletion6 = true;
var _didIteratorError6 = false;
var _iteratorError6 = undefined;
try {
for (var _iterator6 = (0, _getIterator3.default)(envComponents), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
var component = _step6.value;
if (typeof component !== 'string') {
components.push(component);
} else {
// split around special characters
var re = /([^\x00-\x1f]+)|([\x00-\x1f]+)/gm;
var m = void 0;
while ((m = re.exec(component)) !== null) {
if (m[1]) {
components.push(m[1]);
} else {
components.push(this._escapeSequenceDynamicValue(m[2]));
}
}
}
}
} catch (err) {
_didIteratorError6 = true;
_iteratorError6 = err;
} finally {
try {
if (!_iteratorNormalCompletion6 && _iterator6.return) {
_iterator6.return();
}
} finally {
if (_didIteratorError6) {
throw _iteratorError6;
}
}
}
return new (Function.prototype.bind.apply(_PawShims.DynamicString, [null].concat(components)))();
}
// @tested
}, {
key: '_resolveFileReference',
value: function _resolveFileReference(value) {
if (value instanceof _apiFlow.FileReference) {
var dv = new _PawShims.DynamicValue('com.luckymarmot.FileContentDynamicValue', {});
var ds = new _PawShims.DynamicString(dv);
return ds;
}
return value;
}
// @tested
}, {
key: '_convertCharToHex',
value: function _convertCharToHex(char) {
var hexChar = char.charCodeAt(0).toString(16);
if (hexChar.length === 1) {
hexChar = '0' + hexChar;
}
return hexChar;
}
// @tested
}, {
key: '_escapeCharSequence',
value: function _escapeCharSequence(seq) {
var escapedChars = {
'\n': '\\n',
'\r': '\\r',
'\t': '\\t'
};
var escapeSequence = '';
var _iteratorNormalCompletion7 = true;
var _didIteratorError7 = false;
var _iteratorError7 = undefined;
try {
for (var _iterator7 = (0, _getIterator3.default)(seq), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
var char = _step7.value;
escapeSequence += escapedChars[char] ? escapedChars[char] : '\\x' + this._convertCharToHex(char);
}
} catch (err) {
_didIteratorError7 = true;
_iteratorError7 = err;
} finally {
try {
if (!_iteratorNormalCompletion7 && _iterator7.return) {
_iterator7.return();
}
} finally {
if (_didIteratorError7) {
throw _iteratorError7;
}
}
}
return escapeSequence;
}
// @tested
}, {
key: '_escapeSequenceDynamicValue',
value: function _escapeSequenceDynamicValue(seq) {
var escapeSequence = this._escapeCharSequence(seq);
return new _PawShims.DynamicValue('com.luckymarmot.EscapeSequenceDynamicValue', {
escapeSequence: escapeSequence
});
}
// @tested
}, {
key: '_castReferenceToDynamicString',
value: function _castReferenceToDynamicString(reference) {
var _this7 = this;
var components = reference.get('referenceName');
var dynStr = [];
components.forEach(function (component) {
var value = _this7._extractReferenceComponent(component);
if (value) {
dynStr.push(value);
}
});
return new (Function.prototype.bind.apply(_PawShims.DynamicString, [null].concat(dynStr)))();
}
/*
This does not extract all reference components,
but only the simple ones. e.g. a {{var1}} will
be extracted as var1, but {{{{var2}}}} won't.
{{var{{number}}}} also won't be extracted.
This is because Paw does not support variable
environment references: {{var{{number}}}} could
resolve to {{var1}}, {{var2}}, etc. depending on
the value {{number}} resolves to, and we can't
know if they exist, as {{number}} can be changed
on the fly by the user.
*/
// @tested
}, {
key: '_extractReferenceComponent',
value: function _extractReferenceComponent(component) {
if (typeof component === 'string') {
return component;
}
if (component instanceof _apiFlow.EnvironmentReference && component.get('referenceName').size === 1 && typeof component.getIn(['referenceName', 0]) === 'string') {
var envVariable = this._getEnvironmentVariable(component.getIn(['referenceName', 0]));
return new _PawShims.DynamicValue('com.luckymarmot.EnvironmentVariableDynamicValue', {
environmentVariable: envVariable.id
});
}
return null;
}
}]);
return BaseImporter;
}(), _class.fileExtensions = [], _class.inputs = [], _temp);
exports.default = BaseImporter;