@lskjs/server-api/lib/Api.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = exports.Api = void 0;
var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
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 _get3 = _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 _get4 = _interopRequireDefault(require("lodash/get"));
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; } }
// import hash from 'object-hash';
// import Cacheman from 'cacheman';
// import pick from 'lodash/pick';
// import isArray from 'lodash/isArray';
// import set from 'lodash/set';
// import forEach from 'lodash/forEach';
// import tryJSONparse from '@lskjs/utils/tryJSONparse';
// import autobind from '@lskjs/utils/autobind';
// import mapValues from 'lodash/mapValues';
// import map from 'lodash/map';
// import some from 'lodash/some';
// import getDocsTemplate from './getDocsTemplate';
var Api = /*#__PURE__*/function (_Module) {
  (0, _inherits2["default"])(Api, _Module);
  var _super = _createSuper(Api);
  function Api(parent) {
    var _this2;
    var _this;
    (0, _classCallCheck2["default"])(this, Api);
    for (var _len = arguments.length, propsArray = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      propsArray[_key - 1] = arguments[_key];
    }
    _this = _super.call.apply(_super, [this, parent].concat(propsArray));
    _this.__api = true;
    (_this2 = _this).setProps.apply(_this2, propsArray.concat([{
      '__lifecycle.create': new Date(),
      __parent: parent,
      app: parent && parent.app,
      config: parent && parent.config
    }]));
    // this.__parent = parent;
    // this.app = parent && parent.app;
    // this.__config = parent && parent.config;
    return _this;
  }
  (0, _createClass2["default"])(Api, [{
    key: "init",
    value: function () {
      var _init = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
        var _get2;
        var _len2,
          propsArray,
          _key2,
          _args = arguments;
        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              for (_len2 = _args.length, propsArray = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                propsArray[_key2] = _args[_key2];
              }
              _context.next = 3;
              return (_get2 = (0, _get3["default"])((0, _getPrototypeOf2["default"])(Api.prototype), "init", this)).call.apply(_get2, [this].concat(propsArray));
            case 3:
              if (this.app) {
                _context.next = 5;
                break;
              }
              throw new _err["default"]("API_APP_MISSING', 'Please use new ".concat(this.name, "(this) instead new ").concat(this.name, "(this.app)"));
            case 5:
              if (this.__parent) {
                _context.next = 7;
                break;
              }
              throw new _err["default"]("API_PARENT_MISSING', 'Please use new ".concat(this.name, "(this) instead new ").concat(this.name, "(this.app)"));
            case 7:
              this.paths = [].concat((0, _toConsumableArray2["default"])(this.__parent.paths || []), [this.path]);
            case 8:
            case "end":
              return _context.stop();
          }
        }, _callee, this);
      }));
      function init() {
        return _init.apply(this, arguments);
      }
      return init;
    }() // async isAuth(req) {
    //   if (req.__errJwt) return false;
    //   if (!get(req, 'user._id')) return false;
    //   return true;
    // }
  }, {
    key: "checkAuth",
    value: function () {
      var _checkAuth = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(req) {
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) switch (_context2.prev = _context2.next) {
            case 0:
              if (!req.__errJwt) {
                _context2.next = 2;
                break;
              }
              throw req.__errJwt;
            case 2:
              if ((0, _get4["default"])(req, 'user._id')) {
                _context2.next = 4;
                break;
              }
              throw new _err["default"]('auth.unauthorized', {
                status: 401
              });
            case 4:
            case "end":
              return _context2.stop();
          }
        }, _callee2);
      }));
      function checkAuth(_x) {
        return _checkAuth.apply(this, arguments);
      }
      return checkAuth;
    }() // async isAdmin(req) {
    //   if (req.__errJwt) return false;
    //   if (!get(req, 'user._id')) return false;
    //   if (!get(req, 'user.role') !== 'admin') return false;
    //   return true;
    // }
  }, {
    key: "checkAdmin",
    value: function () {
      var _checkAdmin = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(req) {
        var props,
          _args3 = arguments;
        return _regenerator["default"].wrap(function _callee3$(_context3) {
          while (1) switch (_context3.prev = _context3.next) {
            case 0:
              props = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : {};
              if (!(props.dev && _env.isDev)) {
                _context3.next = 3;
                break;
              }
              return _context3.abrupt("return");
            case 3:
              if (!req.__errJwt) {
                _context3.next = 5;
                break;
              }
              throw req.__errJwt;
            case 5:
              if (!((0, _get4["default"])(req, 'user.role') !== 'admin')) {
                _context3.next = 7;
                break;
              }
              throw new _err["default"]('auth.notadmin', {
                status: 403
              });
            case 7:
            case "end":
              return _context3.stop();
          }
        }, _callee3);
      }));
      function checkAdmin(_x2) {
        return _checkAdmin.apply(this, arguments);
      }
      return checkAdmin;
    }()
  }, {
    key: "url",
    value: function url(path, params) {
      return this.app.url((this.path || '/api') + path, params);
    }
  }, {
    key: "useMiddleware",
    value: function () {
      var _useMiddleware = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(middleware, req, res) {
        return _regenerator["default"].wrap(function _callee5$(_context5) {
          while (1) switch (_context5.prev = _context5.next) {
            case 0:
              return _context5.abrupt("return", new Promise(function (resolve, reject) {
                return middleware(req, res, /*#__PURE__*/function () {
                  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(err) {
                    return _regenerator["default"].wrap(function _callee4$(_context4) {
                      while (1) switch (_context4.prev = _context4.next) {
                        case 0:
                          if (!err) {
                            _context4.next = 2;
                            break;
                          }
                          return _context4.abrupt("return", reject(err));
                        case 2:
                          return _context4.abrupt("return", resolve());
                        case 3:
                        case "end":
                          return _context4.stop();
                      }
                    }, _callee4);
                  }));
                  return function (_x6) {
                    return _ref.apply(this, arguments);
                  };
                }());
              }));
            case 1:
            case "end":
              return _context5.stop();
          }
        }, _callee5);
      }));
      function useMiddleware(_x3, _x4, _x5) {
        return _useMiddleware.apply(this, arguments);
      }
      return useMiddleware;
    }()
  }, {
    key: "__getRoutes",
    value: function () {
      var _getRoutes = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
        return _regenerator["default"].wrap(function _callee6$(_context6) {
          while (1) switch (_context6.prev = _context6.next) {
            case 0:
              if (this.__lifecycle.runStart) {
                _context6.next = 3;
                break;
              }
              _context6.next = 3;
              return this.__run();
            case 3:
              return _context6.abrupt("return", this.getRoutes());
            case 4:
            case "end":
              return _context6.stop();
          }
        }, _callee6, this);
      }));
      function __getRoutes() {
        return _getRoutes.apply(this, arguments);
      }
      return __getRoutes;
    }()
  }, {
    key: "getRoutes",
    value: function getRoutes() {
      return {
        '/': this.index.bind(this)
      };
    }
  }, {
    key: "index",
    value: function () {
      var _index = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7() {
        return _regenerator["default"].wrap(function _callee7$(_context7) {
          while (1) switch (_context7.prev = _context7.next) {
            case 0:
              return _context7.abrupt("return", "".concat(this.name, " \u2013 ok"));
            case 1:
            case "end":
              return _context7.stop();
          }
        }, _callee7, this);
      }));
      function index() {
        return _index.apply(this, arguments);
      }
      return index;
    }()
  }, {
    key: "e404",
    value: function e404(req) {
      throw new _err["default"]('E_404', {
        status: 404,
        message: "Not found path ".concat(req.path),
        path: req.path,
        level: 'warn'
      });
    }

    // cacheStore = new Cacheman('api', {
    //   ttl: 60,
    // });
    // e(...args) {
    //   return new Err(...args);
    // }

    // async validateParams(data, fields) {
    //   const errors = map(fields, (validator, param) => {
    //     if (validator && validator.required && data[param] == null) {
    //       return {
    //         name: 'api.validateParams.required',
    //         param,
    //       };
    //     }
    //     return undefined;
    //   }).filter(Boolean);

    //   if (some(errors, Boolean)) {
    //     throw new Err({
    //       code: 'api.validateParams',
    //       status: 400,
    //       data: {
    //         errors,
    //       },
    //     });
    //   }

    //   return mapValues(fields, (validator, param) => {
    //     const aliases = [param, ...(validator.alias || [])];
    //     // eslint-disable-next-line no-restricted-syntax
    //     for (const param2 of aliases) {
    //       if (data[param2] != null) return data[param2];
    //     }
    //     return null;
    //   });
    // }

    // getListParams(req) {
    //   const { data } = req;
    //   const params = mapValues(pick(data, ['filter', 'sort', 'skip', 'limit', 'select', 'view', 'operation']), (a) =>
    //     tryJSONparse(a),
    //   );

    //   if (!params.filter) params.filter = {};
    //   if (req.data) {
    //     forEach(req.data, (val, key) => {
    //       if (key.substr(0, 'filter.'.length) === 'filter.') {
    //         set(params, key, val);
    //       }
    //       if (key.substr(0, 'sort.'.length) === 'sort.') {
    //         set(params, key, val);
    //       }
    //     });
    //   }
    //   if (params.limit > 100) params.limit = 100;
    //   if (!params.select) params.select = [];
    //   if (typeof params.select === 'string') {
    //     params.select = params.select
    //       .trim()
    //       .split(',')
    //       .map((a) => a.trim());
    //   }
    //   if (!isArray(params.select)) throw new Err('select not array');
    //   if (!params.view) params.view = 'default';
    //   // params.operation = req.data.operation;

    //   return params;
    // }

    // getGteLte(item) {
    //   const $gte = get(item, '[0]');
    //   const $lte = get(item, '[1]');
    //   const res = {};
    //   if ($lte !== null && typeof $lte !== 'undefined') {
    //     res.$lte = $lte;
    //   }
    //   if ($gte !== null && typeof $gte !== 'undefined') {
    //     res.$gte = $gte;
    //   }
    //   if (!Object.keys(res).length) return null;
    //   return res;
    // }
    // assign(model, params, fields = []) {
    //   if (fields.length === 0) {
    //     console.error('Api.assign empty fields'); // eslint-disable-line no-console
    //     return;
    //   }
    //   fields.forEach((field) => {
    //     if (params[field] === undefined) return;
    //     model[field] = params[field]; // eslint-disable-line no-param-reassign
    //     if (!model.markModified) return;
    //     model.markModified(field);
    //   });
    // }
    // isAdmin(req) {
    //   if (req.user?.role !== 'admin') throw this.e(403, '!admin');
    //   // return req.user?.role === 'admin';
    // }
    // equal(objectId1, objectId2) {
    //   return String(objectId1) === String(objectId2);
    // }
    // findAndCountByParams(Model, params, params2) {
    //   const { then = (a) => a } = params2; //  = a => a
    //   return Promise.props({
    //     __pack: 1,
    //     count: params.count || params.count === '' ? Model.countByParams(params) : undefined,
    //     data: Model.prepare(then(Model.findByParams(params, params2)), params2),
    //   });
    // }
    // withSearchParams(data, field) {
    //   const { search, filter = {}, ...other } = data;
    //   if (!search) return data;
    //   return {
    //     ...other,
    //     filter: {
    //       ...filter,
    //       $and: [
    //         {
    //           [field]: {
    //             $regex: search,
    //             $options: 'i',
    //           },
    //         },
    //       ],
    //     },
    //   };
    // }
    // enableCache = false;
    // async cache(key, ...args) {
    //   const [fn, params = { ttl: 60 }] = args.reverse();
    //   if (!this.enableCache) return fn();
    //   const { ttl } = params;
    //   let hashedKey;
    //   try {
    //     hashedKey = hash(key);
    //   } catch (err) {
    //     try {
    //       hashedKey = hash(JSON.stringify(key));
    //     } catch (err2) {
    //       console.error('Api.cache', err2);  //eslint-disable-line
    //       hashedKey = '!!!ERR!!!';
    //     }
    //   }
    //   const value = await this.cacheStore.get(hashedKey);
    //   if (value) return value;
    //   const res = await fn();
    //   this.cacheStore.set(hashedKey, res, ttl);
    //   return res;
    // }

    // getDocsRoutes({ path, ...props } = {}) {
    //   const params = {
    //     name: get(this, 'app.config.about.title'),
    //     description: get(this, 'app.config.about.description'),
    //     docs: path ? this.app.url(`${path}/docs`) : this.url('/docs'),
    //     docsJson: path ? this.app.url(`${path}/docs.json`) : this.url('/docs.json'),
    //     path,
    //     ...props,
    //   };
    //   return {
    //     '': () => params,
    //     '/docs': (req, res) => res.send(getDocsTemplate(params)),
    //     '/docs.json': (req, res) => res.json(this.getDocs(this, params)),
    //   };
    // }
  }]);
  return Api;
}(_module["default"]);
exports.Api = Api;
var _default = Api;
exports["default"] = _default;
//# sourceMappingURL=Api.js.map