annotated-graphql/dist/annotations/rest-schema-annotation.js

Annotated GraphQL

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

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 _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

var _request = require('request');

var _request2 = _interopRequireDefault(_request);

var _dataloader = require('dataloader');

var _dataloader2 = _interopRequireDefault(_dataloader);

var _baseSchemaAnnotation = require('./base-schema-annotation');

var _baseSchemaAnnotation2 = _interopRequireDefault(_baseSchemaAnnotation);

var _lib = require('../lib');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

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; }

var requestDefaultsInitialValues = {
    json: true,
    jar: true
};

// TODO: document

var RestSchemaAnnotation = function (_BaseSchemaAnnotation) {
    _inherits(RestSchemaAnnotation, _BaseSchemaAnnotation);

    function RestSchemaAnnotation(typeName, fieldName) {
        var argumentMap = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];

        _classCallCheck(this, RestSchemaAnnotation);

        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(RestSchemaAnnotation).call(this, RestSchemaAnnotation.TAG, typeName, fieldName));

        _this.argumentMap = argumentMap;
        return _this;
    }

    _createClass(RestSchemaAnnotation, [{
        key: 'onCreateResolver',
        value: function onCreateResolver(resolvers, resolversContext) {
            _get(Object.getPrototypeOf(RestSchemaAnnotation.prototype), 'onCreateResolver', this).call(this, resolvers, resolversContext);

            var type = (0, _lib.getOrCreate)(resolvers, this.typeName),
                requestDefaults = (0, _lib.getOrCreate)(resolversContext, '_requestDefaults', requestDefaultsInitialValues);

            if (this.fieldName) {
                type[this.fieldName] = this._createResolver(_request2.default, requestDefaults);
            } else {
                this._applyToRequestDefaults(requestDefaults);
            }
        }
    }, {
        key: '_applyToRequestDefaults',
        value: function _applyToRequestDefaults(requestDefaults) {
            if (this.argumentMap.basicAuthorization) {
                applyBasicAuthorization(this.argumentMap.basicAuthorization, requestDefaults);
            }

            if (this.argumentMap.baseUrl) {
                requestDefaults.baseUrl = this.argumentMap.baseUrl;
            }

            function applyBasicAuthorization(basicAuthorization, requestDefaults) {
                basicAuthorization = processEnvVariables(basicAuthorization);

                Object.assign(requestDefaults, {
                    headers: { 'Authorization': 'Basic ' + basicAuthorization }
                });

                function processEnvVariables(basicAuthorization) {
                    var envVariableName = (basicAuthorization.match(/\{\{(.*)\}\}/) || [])[1];

                    return envVariableName ? process.env[envVariableName] : basicAuthorization;
                }
            }
        }
    }, {
        key: '_createResolver',
        value: function _createResolver(request, requestDefaults) {
            var _this2 = this;

            return function (root, args, context) {
                var nonEmptyParameters = filterEmptyParameters(args, _this2.argumentMap.parameters || Object.keys(args));

                var _consumeUrlParameters = consumeUrlParameters(_this2.argumentMap.url, nonEmptyParameters);

                var url = _consumeUrlParameters.url;
                var parameters = _consumeUrlParameters.parameters;
                var dataLoader = getDataLoader(context);
                var requestKey = {
                    method: _this2.argumentMap.method || 'get',
                    url: url,
                    parameters: parameters,
                    resultField: _this2.argumentMap.resultField
                };

                return dataLoader ? dataLoader.load(requestKey) : makeRequest(requestKey);

                function makeRequest(_ref) {
                    var method = _ref.method;
                    var url = _ref.url;
                    var parameters = _ref.parameters;
                    var resultField = _ref.resultField;

                    var requestArgs = Object.assign({}, requestDefaults, _defineProperty({
                        url: url
                    }, method === 'get' ? 'qs' : 'body', parameters));

                    return new Promise(function (resolve) {
                        return request[method](requestArgs, function (error, response, body) {
                            return resolve(resultField ? body[resultField] : body);
                        });
                    });
                }

                function getDataLoader(context) {
                    if (context) {
                        var restDataLoader = context._restDataLoader;

                        if (!restDataLoader) {
                            restDataLoader = new _dataloader2.default(function (keys) {
                                return Promise.all(keys.map(makeRequest));
                            }, {
                                cacheKeyFn: serializeRequestKey
                            });

                            context._restDataLoader = restDataLoader;
                        }

                        return restDataLoader;
                    } else {
                        console.info('No context provided to REST annotation resolver, so no REST data loader used.');
                    }
                }

                function serializeRequestKey(_ref2) {
                    var method = _ref2.method;
                    var url = _ref2.url;
                    var parameters = _ref2.parameters;
                    var resultField = _ref2.resultField;

                    var serializedParameters = Object.keys(parameters).map(function (parameterName) {
                        return parameterName + '=' + parameters[parameterName];
                    }).join(':');

                    return method + ':' + url + ':' + serializedParameters + ':' + resultField;
                }
            };
        }
    }]);

    return RestSchemaAnnotation;
}(_baseSchemaAnnotation2.default);

RestSchemaAnnotation.TAG = 'rest';

RestSchemaAnnotation.factory = function (directiveInfo, typeName, fieldName) {
    if (directiveInfo.tag === RestSchemaAnnotation.TAG) {
        return new RestSchemaAnnotation(typeName, fieldName, _baseSchemaAnnotation2.default.asArgumentsMap(directiveInfo.arguments));
    }
};

exports.default = RestSchemaAnnotation;


function filterEmptyParameters(sourceParameters, targetParameterNames) {
    return targetParameterNames.reduce(filterEmptyParameter, {});

    function filterEmptyParameter(nonEmptyParameters, parameterName) {
        if (sourceParameters[parameterName] !== undefined) {
            nonEmptyParameters[parameterName] = sourceParameters[parameterName];
        }

        return nonEmptyParameters;
    }
}

function consumeUrlParameters(url, parameters) {
    return {
        url: url.replace(/(\{(.*?)\})/g, createParameterReplacer(parameters)),
        parameters: parameters
    };

    function createParameterReplacer(parameters) {
        return function (match, parameterTemplate, parameterName) {
            var parameterValue = parameters[parameterName];

            (0, _lib.invariant)(parameterValue !== undefined, 'Replacement value for url parameter: \'' + parameterName + '\' not found.');

            delete parameters[parameterName];

            return parameterValue;
        };
    }
}