@kiwicom/smart-faq/lib/shared/relay/environment.js

"use strict";

require("core-js/modules/es.symbol");

require("core-js/modules/es.symbol.description");

require("core-js/modules/es.symbol.iterator");

require("core-js/modules/es.array.filter");

require("core-js/modules/es.array.for-each");

require("core-js/modules/es.array.from");

require("core-js/modules/es.array.iterator");

require("core-js/modules/es.array.some");

require("core-js/modules/es.date.to-string");

require("core-js/modules/es.function.name");

require("core-js/modules/es.object.get-own-property-descriptor");

require("core-js/modules/es.object.get-own-property-descriptors");

require("core-js/modules/es.object.keys");

require("core-js/modules/es.object.to-string");

require("core-js/modules/es.promise");

require("core-js/modules/es.regexp.to-string");

require("core-js/modules/es.string.iterator");

require("core-js/modules/web.dom-collections.for-each");

require("core-js/modules/web.dom-collections.iterator");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.fetchQuery = fetchQuery;
exports.default = exports.ERROR_FORBIDDEN = exports.rawCache = exports.cache = void 0;

require("regenerator-runtime/runtime");

require("isomorphic-fetch");

var _relayRuntime = require("relay-runtime");

var _v = _interopRequireDefault(require("uuid/v4"));

var _memoizeOne = _interopRequireDefault(require("memoize-one"));

var _helpers = require("@kiwicom/smart-faq/src/shared/helpers");

var _utils = require("./utils");

var _CustomerSupportPhonesQuery = _interopRequireDefault(require("./../../fallbacks/CustomerSupportPhonesQuery.json"));

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

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var fallbacks = {};
fallbacks["CustomerSupportPhonesQuery"] = _CustomerSupportPhonesQuery.default;
var uri = 'https://graphql.kiwi.com';
var cache = new _relayRuntime.QueryResponseCache({
  size: 200,
  ttl: 30 * 60 * 1000
});
exports.cache = cache;
var rawCache = {};
exports.rawCache = rawCache;
var ERROR_FORBIDDEN = 'Forbidden 403';
exports.ERROR_FORBIDDEN = ERROR_FORBIDDEN;

var getFallbackData = function getFallbackData(error, operation) {
  if (operation.name in fallbacks) {
    return fallbacks[operation.name];
  }

  throw error;
};

var handleForbiddenError = function handleForbiddenError(json) {
  if (json.errors && json.errors.length > 0 && json.errors.some(function (error) {
    var _error$extensions, _error$extensions$pro;

    return (error === null || error === void 0 ? void 0 : (_error$extensions = error.extensions) === null || _error$extensions === void 0 ? void 0 : (_error$extensions$pro = _error$extensions.proxy) === null || _error$extensions$pro === void 0 ? void 0 : _error$extensions$pro.statusCode) === '403';
  })) {
    throw new Error(ERROR_FORBIDDEN);
  }
};

var composeRequestBody = function composeRequestBody(operation, variables) {
  return JSON.stringify({
    query: operation.text,
    // GraphQL text from input
    variables: variables,
    operationName: operation.name
  });
};

var composeRequest = function composeRequest(headers, operation, variables) {
  var _process$env$GRAPHQL_;

  var body = composeRequestBody(operation, variables);
  return [(_process$env$GRAPHQL_ = process.env.GRAPHQL_URI) !== null && _process$env$GRAPHQL_ !== void 0 ? _process$env$GRAPHQL_ : uri, {
    method: 'POST',
    headers: headers,
    body: body
  }];
};

function fetchQuery(_x, _x2, _x3) {
  return _fetchQuery.apply(this, arguments);
}

function _fetchQuery() {
  _fetchQuery = _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee2(headers, operation, variables) {
    var fallbackData, response, errorMetadata, json, result, errors, metadata;
    return regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            fallbackData = null;
            response = null;
            errorMetadata = {
              variables: variables,
              operationName: operation.name,
              requestId: headers['X-Request-ID'],
              locale: headers['Accept-Language']
            };
            _context2.prev = 3;
            _context2.next = 6;
            return fetch.apply(void 0, _toConsumableArray(composeRequest(headers, operation, variables)));

          case 6:
            response = _context2.sent;
            _context2.next = 13;
            break;

          case 9:
            _context2.prev = 9;
            _context2.t0 = _context2["catch"](3);
            // eslint-disable-next-line no-console
            console.error('GraphQL network', _objectSpread({}, errorMetadata, {
              errorMessage: _context2.t0.message
            }));
            fallbackData = getFallbackData(_context2.t0, operation);

          case 13:
            json = fallbackData;

            if (json) {
              _context2.next = 19;
              break;
            }

            _context2.next = 17;
            return response.json();

          case 17:
            result = _context2.sent;
            json = result;

          case 19:
            handleForbiddenError(json);

            if (json.errors) {
              errors = function () {
                try {
                  return JSON.stringify(json.errors);
                } catch (e) {
                  // this would really suck!
                  console.error(e); // eslint-disable-line no-console

                  return {
                    parseError: String(e)
                  };
                }
              }();

              metadata = _objectSpread({}, errorMetadata, {
                errors: errors
              });
              console.error('GraphQL error', metadata); // eslint-disable-line no-console
            }

            return _context2.abrupt("return", json);

          case 22:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2, null, [[3, 9]]);
  }));
  return _fetchQuery.apply(this, arguments);
}

var getSSRCache = function getSSRCache(operation, variables) {
  var _window, _window$__NEXT_DATA__, _window$__NEXT_DATA__2;

  var requestHash = (0, _utils.getRequestHash)({
    operation: operation,
    variables: variables
  });

  if ((0, _helpers.isBrowser)() && ((_window = window) === null || _window === void 0 ? void 0 : (_window$__NEXT_DATA__ = _window.__NEXT_DATA__) === null || _window$__NEXT_DATA__ === void 0 ? void 0 : (_window$__NEXT_DATA__2 = _window$__NEXT_DATA__.props) === null || _window$__NEXT_DATA__2 === void 0 ? void 0 : _window$__NEXT_DATA__2.requestHash) === requestHash) {
    return window.__NEXT_DATA__.props.rawData;
  }

  return null;
};

var buildQueryFetcher = function buildQueryFetcher() {
  var token
  /*: string*/
  = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
  var kwAuthToken
  /*: string*/
  = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
  var locale
  /*: string*/
  = arguments.length > 2 ? arguments[2] : undefined;
  return (
    /*#__PURE__*/
    function () {
      var _ref = _asyncToGenerator(
      /*#__PURE__*/
      regeneratorRuntime.mark(function _callee(operation, variables, cacheConfig) {
        var forceFetch, isQuery, cachedData, headers, json, requestHash;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                forceFetch = (0, _helpers.isBrowser)() ? cacheConfig.force : true;
                isQuery = operation.operationKind === 'query';

                if (!(!forceFetch && isQuery)) {
                  _context.next = 6;
                  break;
                }

                cachedData = cache.get(operation.text, variables);

                if (!cachedData) {
                  _context.next = 6;
                  break;
                }

                return _context.abrupt("return", cachedData);

              case 6:
                headers = {
                  'Content-Type': 'application/json',
                  'Accept-Language': locale,
                  'KW-Auth-Token': kwAuthToken,
                  Authorization: token,
                  'X-Client': 'SmartFAQ',
                  'X-Request-ID': (0, _v.default)()
                }; // Use cache from next.js if available

                _context.t0 = getSSRCache(operation, variables);

                if (_context.t0) {
                  _context.next = 12;
                  break;
                }

                _context.next = 11;
                return fetchQuery(headers, operation, variables);

              case 11:
                _context.t0 = _context.sent;

              case 12:
                json = _context.t0;

                if (!forceFetch && isQuery) {
                  cache.set(operation.text, variables, json);
                }

                requestHash = (0, _utils.getRequestHash)({
                  operation: operation,
                  variables: variables
                });
                rawCache[requestHash] = json;
                return _context.abrupt("return", json);

              case 17:
              case "end":
                return _context.stop();
            }
          }
        }, _callee);
      }));

      return function (_x4, _x5, _x6) {
        return _ref.apply(this, arguments);
      };
    }()
  );
};

var getStore = (0, _memoizeOne.default)(function (records) {
  return new _relayRuntime.Store(new _relayRuntime.RecordSource(records));
}, function () {
  return true;
});

var createEnvironment = function createEnvironment(token
/*: ?string*/
, kwAuthToken
/*: ?string*/
, locale
/*: ?string*/
, records
/*: ?Object*/
) {
  return new _relayRuntime.Environment({
    network: _relayRuntime.Network.create(buildQueryFetcher(token, kwAuthToken, locale)),
    store: getStore(records)
  });
};

var _default = createEnvironment;
exports.default = _default;