@lskjs/bots-router/BotsRouter.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = exports.BotsRouter = void 0;

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

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

var _env = require("@lskjs/env");

var _err = _interopRequireDefault(require("@lskjs/err"));

var _module = _interopRequireDefault(require("@lskjs/module"));

var _bluebird = _interopRequireDefault(require("bluebird"));

var _querystring = _interopRequireDefault(require("querystring"));

var _universalRouter = _interopRequireDefault(require("universal-router"));

var _url = _interopRequireDefault(require("url"));

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(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

var BotsRouter = /*#__PURE__*/function (_Module) {
  (0, _inherits2["default"])(BotsRouter, _Module);

  var _super = _createSuper(BotsRouter);

  function BotsRouter() {
    (0, _classCallCheck2["default"])(this, BotsRouter);
    return _super.apply(this, arguments);
  }

  (0, _createClass2["default"])(BotsRouter, [{
    key: "init",
    value: // debug = true;
    function () {
      var _init = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return (0, _get2["default"])((0, _getPrototypeOf2["default"])(BotsRouter.prototype), "init", this).call(this);

              case 2:
                if (this.routes) {
                  _context.next = 5;
                  break;
                }

                this.log.warn('!routes');
                return _context.abrupt("return");

              case 5:
                if (this.bot.client) {
                  _context.next = 8;
                  break;
                }

                this.log.warn('!client');
                return _context.abrupt("return");

              case 8:
                if (this.bot.client.use) {
                  _context.next = 11;
                  break;
                }

                this.log.warn('!client.use');
                return _context.abrupt("return");

              case 11:
                this.log.trace('routes', this.routes.map(function (c) {
                  return c.path;
                }).filter(Boolean));
                this.router = new _universalRouter["default"](this.routes);
                this.bot.client.use(this.middleware.bind(this));

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

      function init() {
        return _init.apply(this, arguments);
      }

      return init;
    }()
  }, {
    key: "middleware",
    value: function () {
      var _middleware = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(ctx, next) {
        var props, res;
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                // console.log('ctx.session.nextRoute', ctx.session.nextRoute);
                // console.log('ctx.session.nextRoute', ctx.session.defaultRoute);
                props = this.getPathFromEvent(ctx); // console.log('routerPath', { routerPath });

                _context2.next = 3;
                return this.resolve(_objectSpread({
                  ctx: ctx
                }, props));

              case 3:
                res = _context2.sent;
                return _context2.abrupt("return", next(ctx));

              case 5:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function middleware(_x, _x2) {
        return _middleware.apply(this, arguments);
      }

      return middleware;
    }()
  }, {
    key: "parsePathnameAndQuery",
    value: function parsePathnameAndQuery(str) {
      var _url$parse = _url["default"].parse(str),
          pathname = _url$parse.pathname,
          queryString = _url$parse.query;

      var query = queryString && queryString.length ? _querystring["default"].decode(queryString) : undefined;
      return {
        pathname: pathname,
        query: query
      };
    }
  }, {
    key: "getPathFromEvent",
    value: function getPathFromEvent(ctx) {
      var _ctx$session = ctx.session,
          session = _ctx$session === void 0 ? {} : _ctx$session;

      if (this.bot.isMessageCallback(ctx)) {
        delete session.nextRoute;
        return this.parsePathnameAndQuery(this.bot.getMessageCallbackData(ctx));
      }

      if (this.bot.isMessageCommand(ctx)) {
        delete session.nextRoute;
        return this.parsePathnameAndQuery(this.bot.getMessageCommand(ctx));
      }

      if (session.nextRoute) {
        var nextRoute = session.nextRoute;
        delete session.nextRoute;
        if (typeof nextRoute === 'string') return this.parsePathnameAndQuery(nextRoute);
        return nextRoute;
      }

      if (this.bot.isMessageStartsWithEmoji(ctx)) {
        var emojies = this.bot.getMessageStartsEmojiArray(ctx);
        if (!emojies.length) return null;
        return {
          path: "/".concat(emojies.join('/'))
        };
      }

      return session.defaultRoute || null;
    } // redirect(ctx, routerPath) {
    //   ctx.session.routerPath = routerPath;
    //   return this.resolve(ctx);
    // }

  }, {
    key: "provide",
    value: function () {
      var _provide = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(_ref) {
        var _ref$user, locale, i18Module, i18;

        return _regenerator["default"].wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                _ref$user = _ref.user;
                _ref$user = _ref$user === void 0 ? {} : _ref$user;
                locale = _ref$user.locale;
                _context3.next = 5;
                return this.app.module('i18');

              case 5:
                i18Module = _context3.sent;
                _context3.next = 8;
                return i18Module.instance(locale, {
                  anyLocale: true,
                  throwError: false
                });

              case 8:
                i18 = _context3.sent;
                return _context3.abrupt("return", {
                  app: this.app,
                  router: this,
                  botsModule: this.app.botsModule,
                  bot: this.bot,
                  i18: i18,
                  module: this.app.module,
                  log: this.log
                });

              case 10:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function provide(_x3) {
        return _provide.apply(this, arguments);
      }

      return provide;
    }()
  }, {
    key: "resolve",
    value: function () {
      var _resolve = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
        var _this = this;

        var _ref2,
            pathname,
            path,
            _ref2$query,
            query,
            ctx,
            provide,
            req,
            data,
            _args6 = arguments;

        return _regenerator["default"].wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                _ref2 = _args6.length > 0 && _args6[0] !== undefined ? _args6[0] : {}, pathname = _ref2.pathname, path = _ref2.path, _ref2$query = _ref2.query, query = _ref2$query === void 0 ? {} : _ref2$query, ctx = _ref2.ctx;
                // eslint-disable-next-line no-param-reassign
                if (!path && pathname) path = pathname; // const { routerPath: pathname } = ctx.session;

                if (path) {
                  _context6.next = 5;
                  break;
                }

                if (this.debug) this.log.warn('!path');
                return _context6.abrupt("return", null);

              case 5:
                if (ctx) {
                  _context6.next = 8;
                  break;
                }

                if (this.debug) this.log.warn('!ctx');
                return _context6.abrupt("return", null);

              case 8:
                if (this.debug) this.log.trace('resolve', path);

                ctx.nextRedirect = /*#__PURE__*/function () {
                  var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(path, query) {
                    var props;
                    return _regenerator["default"].wrap(function _callee4$(_context4) {
                      while (1) {
                        switch (_context4.prev = _context4.next) {
                          case 0:
                            if (path) {
                              _context4.next = 2;
                              break;
                            }

                            throw new _err["default"]('!path');

                          case 2:
                            props = {};

                            if (typeof path === 'string') {
                              props = {
                                path: path
                              };
                            } else {
                              props = path;
                            }

                            if (!props.query && query) props.query = query;
                            if (!ctx.session) ctx.session = {};
                            ctx.session.nextRoute = props;

                            if (_env.isDev) {
                              _this.log.info("nextRedirect =>  ".concat(JSON.stringify(props))); // await Bluebird.delay(1000);

                            }

                            return _context4.abrupt("return", props);

                          case 9:
                          case "end":
                            return _context4.stop();
                        }
                      }
                    }, _callee4);
                  }));

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

                ctx.redirect = /*#__PURE__*/function () {
                  var _ref4 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(path, query) {
                    var props;
                    return _regenerator["default"].wrap(function _callee5$(_context5) {
                      while (1) {
                        switch (_context5.prev = _context5.next) {
                          case 0:
                            if (path) {
                              _context5.next = 2;
                              break;
                            }

                            throw new _err["default"]('!path');

                          case 2:
                            props = {};

                            if (typeof path === 'string') {
                              props = {
                                path: path
                              };
                            } else {
                              props = path;
                            }

                            if (!props.query && query) props.query = query;

                            if (!_env.isDev) {
                              _context5.next = 9;
                              break;
                            }

                            _this.log.info("redirect => ".concat(props.path || props.pathname, " ").concat(JSON.stringify(props.query), " [delay] ", 1000));

                            _context5.next = 9;
                            return _bluebird["default"].delay(1000);

                          case 9:
                            return _context5.abrupt("return", _this.resolve(_objectSpread({
                              ctx: ctx
                            }, props)));

                          case 10:
                          case "end":
                            return _context5.stop();
                        }
                      }
                    }, _callee5);
                  }));

                  return function (_x6, _x7) {
                    return _ref4.apply(this, arguments);
                  };
                }();

                _context6.next = 13;
                return this.provide({});

              case 13:
                provide = _context6.sent;
                req = {
                  path: path,
                  pathname: path,
                  bot: provide.bot,
                  log: this.log,
                  ctx: ctx,
                  query: query,
                  i18: provide.i18,
                  t: provide.i18 && provide.i18.t
                };
                data = _objectSpread(_objectSpread({}, provide), {}, {
                  req: req,
                  path: path,
                  pathname: path,
                  query: query,
                  ctx: ctx
                });
                if (this.debug) this.log.trace('context', Object.keys(data));
                return _context6.abrupt("return", this.router.resolve(data)["catch"](function (err) {
                  _this.log.error('err', err);

                  throw err;
                }));

              case 18:
              case "end":
                return _context6.stop();
            }
          }
        }, _callee6, this);
      }));

      function resolve() {
        return _resolve.apply(this, arguments);
      }

      return resolve;
    }()
  }]);
  return BotsRouter;
}(_module["default"]);

exports.BotsRouter = BotsRouter;
var _default = BotsRouter;
exports["default"] = _default;
//# sourceMappingURL=BotsRouter.js.map