mirage-openapi/lib/mirage-openapi.js

Mock OpenAPI responses in ember-cli-mirage

'use strict';

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

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _parseConfigs = require('./utils/parse-configs');

var _parseConfigs2 = _interopRequireDefault(_parseConfigs);

var _configurePassthrus = require('./utils/configure-passthrus');

var _configurePassthrus2 = _interopRequireDefault(_configurePassthrus);

var _handlerForRequest = require('./utils/handler-for-request');

var _handlerForRequest2 = _interopRequireDefault(_handlerForRequest);

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

var MirageOpenAPI = function () {
  function MirageOpenAPI(_ref) {
    var configs = _ref.configs,
        server = _ref.server;
    (0, _classCallCheck3.default)(this, MirageOpenAPI);

    this.server = server;
    this.configs = configs;
    this._routers = undefined;

    this.initialize();
  }

  (0, _createClass3.default)(MirageOpenAPI, [{
    key: 'initialize',
    value: function initialize() {
      var configs = this.configs,
          server = this.server,
          handler = this.handler;

      (0, _configurePassthrus2.default)({ configs: configs, server: server, handler: handler.bind(this) });
    }
  }, {
    key: 'handler',
    value: function () {
      var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(_, request) {
        var routers, handler;
        return _regenerator2.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return this.resolveRouters();

              case 2:
                routers = _context.sent;
                handler = (0, _handlerForRequest2.default)({ request: request, routers: routers });
                return _context.abrupt('return', handler(_, request));

              case 5:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function handler(_x, _x2) {
        return _ref2.apply(this, arguments);
      }

      return handler;
    }()
  }, {
    key: 'resolveRouters',
    value: function () {
      var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2() {
        var configs;
        return _regenerator2.default.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                if (!this._routers) {
                  configs = this.configs;

                  this._routers = (0, _parseConfigs2.default)({ configs: configs });
                }

                return _context2.abrupt('return', this._routers);

              case 2:
              case 'end':
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function resolveRouters() {
        return _ref3.apply(this, arguments);
      }

      return resolveRouters;
    }()
  }]);
  return MirageOpenAPI;
}();

exports.default = MirageOpenAPI;