cardcore/dist/game-middleware.js

"use strict";

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

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

var _regenerator2 = _interopRequireDefault(_regenerator);

exports.default = createGameMiddleware;

var _util = require("@cardcore/util");

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

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

function createGameMiddleware(gameActions, clientActions) {
  var clientFetch = clientActions.clientFetch,
      clientPoll = clientActions.clientPoll,
      clientNext = clientActions.clientNext;


  return function gameMiddleware(store) {
    var _this = this;

    return function (next) {
      return function () {
        var _ref = _asyncToGenerator( /*#__PURE__*/_regenerator2.default.mark(function _callee(action) {
          var prevState, me, prevHash, nextState, nextHash, signedAction, res;
          return _regenerator2.default.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  if (!(typeof action === "function")) {
                    _context.next = 2;
                    break;
                  }

                  return _context.abrupt("return", action(store.dispatch, store.getState));

                case 2:
                  if (gameActions[action.type]) {
                    _context.next = 4;
                    break;
                  }

                  return _context.abrupt("return", Promise.resolve(next(action)));

                case 4:

                  // Okay, it's a game action. Great! Let's handle some special cases first.

                  // Special case: we're loading the state from the server. Pass through.

                  // Resolve the action.
                  prevState = store.getState();
                  me = prevState.client.keys.id;
                  prevHash = null;
                  // Special case until we have an actual blockchain to build on

                  if (action.type !== gameActions.CREATE_GAME) {
                    prevHash = (0, _util.hashState)(prevState);
                  }

                  if (action[_util.REMOTE_ACTION]) {
                    _context.next = 12;
                    break;
                  }

                  action = Object.assign({}, action, {
                    agent: me,
                    prev: prevHash
                  });
                  _context.next = 14;
                  break;

                case 12:
                  if (!(action.prev !== prevHash)) {
                    _context.next = 14;
                    break;
                  }

                  throw new Error("hash mismatch, " + action.next + " !== " + nextHash);

                case 14:
                  next(action);
                  nextState = store.getState();
                  nextHash = (0, _util.hashState)(nextState);

                  if (!action[_util.REMOTE_ACTION]) {
                    _context.next = 22;
                    break;
                  }

                  if (!(action.next !== nextHash)) {
                    _context.next = 20;
                    break;
                  }

                  throw new Error("hash mismatch, " + action.next + " !== " + nextHash);

                case 20:
                  _context.next = 23;
                  break;

                case 22:
                  action = Object.assign({}, action, {
                    next: nextHash
                  });

                case 23:
                  if (action[_util.REMOTE_ACTION]) {
                    _context.next = 43;
                    break;
                  }

                  signedAction = _util.Keys.signAction(prevState, action);
                  res = void 0;
                  _context.prev = 26;
                  _context.next = 29;
                  return store.dispatch(clientFetch("/" + encodeURIComponent(nextHash), {
                    method: "POST",
                    body: signedAction,
                    headers: {
                      "content-type": "application/json"
                    }
                  }));

                case 29:
                  res = _context.sent;
                  _context.next = 35;
                  break;

                case 32:
                  _context.prev = 32;
                  _context.t0 = _context["catch"](26);
                  throw new Error("Failed to create an action. We should probably handle this error.");

                case 35:
                  if (res.ok) {
                    _context.next = 41;
                    break;
                  }

                  _context.t1 = Error;
                  _context.next = 39;
                  return res.text();

                case 39:
                  _context.t2 = _context.sent;
                  throw new _context.t1(_context.t2);

                case 41:
                  _context.next = 45;
                  break;

                case 43:
                  if (_util.Keys.verifyAction(prevState, action)) {
                    _context.next = 45;
                    break;
                  }

                  throw new Error("Remote action failed to verify: " + JSON.stringify(action));

                case 45:
                  _context.next = 47;
                  return store.dispatch(clientNext());

                case 47:
                  store.dispatch(clientPoll());

                case 48:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, _this, [[26, 32]]);
        }));

        return function (_x) {
          return _ref.apply(this, arguments);
        };
      }();
    };
  };
}
//# sourceMappingURL=game-middleware.js.map