@modern-js/server-core/dist/esm/serverBase.js

A Progressive React Framework for modern web development.

import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
import { _ as _class_private_method_get } from "@swc/helpers/_/_class_private_method_get";
import { _ as _class_private_method_init } from "@swc/helpers/_/_class_private_method_init";
import { _ as _create_class } from "@swc/helpers/_/_create_class";
import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
import { server } from "@modern-js/plugin-v2/server";
import { Hono } from "hono";
import { run } from "./context";
import { handleSetupResult } from "./plugins/compat/hooks";
import { loadConfig } from "./utils";
var _applyMiddlewares = /* @__PURE__ */ new WeakSet();
var ServerBase = /* @__PURE__ */ function() {
  "use strict";
  function ServerBase2(options) {
    _class_call_check(this, ServerBase2);
    _class_private_method_init(this, _applyMiddlewares);
    this.plugins = [];
    this.serverContext = null;
    this.options = options;
    this.app = new Hono();
    this.app.use("*", run);
  }
  var _proto = ServerBase2.prototype;
  _proto.init = function init() {
    var _this = this;
    return _async_to_generator(function() {
      var _this_options, serverConfig, cliConfig, mergedConfig, serverContext;
      return _ts_generator(this, function(_state) {
        switch (_state.label) {
          case 0:
            _this_options = _this.options, serverConfig = _this_options.serverConfig, cliConfig = _this_options.config;
            mergedConfig = loadConfig({
              cliConfig,
              serverConfig: serverConfig || {}
            });
            return [
              4,
              server.run({
                plugins: _this.plugins,
                options: _this.options,
                config: mergedConfig,
                handleSetupResult
              })
            ];
          case 1:
            serverContext = _state.sent().serverContext;
            serverContext.serverBase = _this;
            return [
              4,
              serverContext.hooks.onPrepare.call()
            ];
          case 2:
            _state.sent();
            _this.serverContext = serverContext;
            _class_private_method_get(_this, _applyMiddlewares, applyMiddlewares).call(_this);
            return [
              2,
              _this
            ];
        }
      });
    })();
  };
  _proto.addPlugins = function addPlugins(plugins) {
    var _this_plugins;
    (_this_plugins = this.plugins).push.apply(_this_plugins, _to_consumable_array(plugins));
  };
  _create_class(ServerBase2, [
    {
      key: "hooks",
      get: function get() {
        return this.serverContext.hooks;
      }
    },
    {
      key: "all",
      get: function get() {
        return this.app.all.bind(this.app);
      }
    },
    {
      key: "use",
      get: function get() {
        return this.app.use.bind(this.app);
      }
    },
    {
      key: "get",
      get: function get() {
        return this.app.get.bind(this.app);
      }
    },
    {
      key: "post",
      get: function get() {
        return this.app.post.bind(this.app);
      }
    },
    {
      key: "put",
      get: function get() {
        return this.app.put.bind(this.app);
      }
    },
    {
      key: "delete",
      get: function get() {
        return this.app.delete.bind(this.app);
      }
    },
    {
      key: "patch",
      get: function get() {
        return this.app.patch.bind(this.app);
      }
    },
    {
      key: "handle",
      get: function get() {
        return this.app.fetch.bind(this.app);
      }
    },
    {
      key: "request",
      get: function get() {
        return this.app.request.bind(this.app);
      }
    },
    {
      key: "notFound",
      get: function get() {
        return this.app.notFound.bind(this.app);
      }
    },
    {
      key: "onError",
      get: function get() {
        return this.app.onError.bind(this.app);
      }
    }
  ]);
  return ServerBase2;
}();
function applyMiddlewares() {
  var middlewares = this.serverContext.middlewares;
  var preMiddlewares = [];
  var defaultMiddlewares = [];
  var postMiddlewares = [];
  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
  try {
    for (var _iterator = middlewares[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var middleware = _step.value;
      switch (middleware.order) {
        case "pre":
          preMiddlewares.push(middleware);
          break;
        case "post":
          postMiddlewares.push(middleware);
          break;
        default:
          defaultMiddlewares.push(middleware);
      }
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return != null) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }
  var finalMiddlewares = [];
  var insertMiddleware = function(middleware2) {
    if (middleware2.before) {
      var targetIndex = finalMiddlewares.findIndex(function(item) {
        var _middleware_before;
        if ((_middleware_before = middleware2.before) === null || _middleware_before === void 0 ? void 0 : _middleware_before.includes(item.name)) {
          return true;
        } else {
          return false;
        }
      });
      if (targetIndex !== -1) {
        finalMiddlewares.splice(targetIndex, 0, middleware2);
      } else {
        finalMiddlewares.push(middleware2);
      }
    } else {
      finalMiddlewares.push(middleware2);
    }
  };
  preMiddlewares.forEach(insertMiddleware);
  defaultMiddlewares.forEach(insertMiddleware);
  postMiddlewares.forEach(insertMiddleware);
  var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
  try {
    for (var _iterator1 = finalMiddlewares[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
      var middleware1 = _step1.value;
      var _this_app;
      var _middleware_path = middleware1.path, path = _middleware_path === void 0 ? "*" : _middleware_path, _middleware_method = middleware1.method, method = _middleware_method === void 0 ? "all" : _middleware_method, handler = middleware1.handler;
      var handlers = handler2Handlers(handler);
      (_this_app = this.app)[method].apply(_this_app, [
        path
      ].concat(_to_consumable_array(handlers)));
    }
  } catch (err) {
    _didIteratorError1 = true;
    _iteratorError1 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
        _iterator1.return();
      }
    } finally {
      if (_didIteratorError1) {
        throw _iteratorError1;
      }
    }
  }
  function handler2Handlers(handler2) {
    if (Array.isArray(handler2)) {
      return handler2;
    } else {
      return [
        handler2
      ];
    }
  }
}
function createServerBase(options) {
  if (options == null) {
    throw new Error("can not start server without options");
  }
  var server2 = new ServerBase(options);
  return server2;
}
export {
  ServerBase,
  createServerBase
};