@modern-js/server-core 2.53.0 → 2.54.0

package/dist/esm/plugins/monitor.js

@@ -0,0 +1,120 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { time } from "@modern-js/runtime-utils/time";
+import { ServerReportTimings } from "../constants";
+var defaultReporter = {
+  init: function init() {
+  },
+  reportError: function reportError() {
+  },
+  reportTiming: function reportTiming() {
+  },
+  reportInfo: function reportInfo() {
+  },
+  reportWarn: function reportWarn() {
+  }
+};
+function initReporter(entryName) {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var reporter, getCost, cost;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            reporter = c.get("reporter");
+            if (!!reporter)
+              return [
+                3,
+                2
+              ];
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+          case 2:
+            return [
+              4,
+              reporter.init({
+                entryName
+              })
+            ];
+          case 3:
+            _state.sent();
+            getCost = time();
+            return [
+              4,
+              next()
+            ];
+          case 4:
+            _state.sent();
+            cost = getCost();
+            reporter.reportTiming(ServerReportTimings.SERVER_HANDLE_REQUEST, cost);
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+var monitorPlugin = function(options) {
+  return {
+    name: "@modern-js/plugin-monitor",
+    setup: function setup(api) {
+      return {
+        prepare: function prepare() {
+          var middlewares = api.useAppContext().middlewares;
+          middlewares.push({
+            name: "monitor",
+            handler: function() {
+              var _ref = _async_to_generator(function(c, next) {
+                var logger, metrics, reporter;
+                return _ts_generator(this, function(_state) {
+                  switch (_state.label) {
+                    case 0:
+                      logger = c.get("logger");
+                      if (!logger && options.logger) {
+                        c.set("logger", options.logger);
+                      }
+                      metrics = c.get("metrics");
+                      if (!metrics && options.metrics) {
+                        c.set("metrics", metrics);
+                      }
+                      reporter = c.get("reporter");
+                      if (!reporter) {
+                        c.set("reporter", reporter || defaultReporter);
+                      }
+                      return [
+                        4,
+                        next()
+                      ];
+                    case 1:
+                      _state.sent();
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(c, next) {
+                return _ref.apply(this, arguments);
+              };
+            }()
+          });
+        }
+      };
+    }
+  };
+};
+export {
+  initReporter,
+  monitorPlugin
+};

package/dist/esm/plugins/processedBy.js

@@ -0,0 +1,42 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+var processedByPlugin = function() {
+  return {
+    name: "@modern-js/plugin-processed",
+    setup: function setup(api) {
+      return {
+        prepare: function prepare() {
+          var middlewares = api.useAppContext().middlewares;
+          middlewares.push({
+            name: "processed-by",
+            handler: function() {
+              var _ref = _async_to_generator(function(c, next) {
+                return _ts_generator(this, function(_state) {
+                  switch (_state.label) {
+                    case 0:
+                      return [
+                        4,
+                        next()
+                      ];
+                    case 1:
+                      _state.sent();
+                      c.header("X-Processed-By", "Modern.js");
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(c, next) {
+                return _ref.apply(this, arguments);
+              };
+            }()
+          });
+        }
+      };
+    }
+  };
+};
+export {
+  processedByPlugin
+};

package/dist/esm/plugins/render/index.js

@@ -0,0 +1,229 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import { initReporter } from "../monitor";
+import { sortRoutes } from "../../utils";
+import { getLoaderCtx, CustomServer, getServerMidFromUnstableMid } from "../customServer";
+import { createRender } from "./render";
+var renderPlugin = function() {
+  var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  return {
+    name: "@modern-js/plugin-render",
+    setup: function setup(api) {
+      var staticGenerate = options.staticGenerate, cacheConfig = options.cacheConfig;
+      return {
+        prepare: function prepare() {
+          return _async_to_generator(function() {
+            var _config_render, _config_render1, _api_useAppContext, middlewares, routes, metaName, pwd, serverBase, runner, config, customServer, serverMiddleware, pageRoutes, render, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, originUrlPath, entryName, urlPath, customServerHookMiddleware, customServerMiddleware, _tmp, err;
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, routes = _api_useAppContext.routes, metaName = _api_useAppContext.metaName, pwd = _api_useAppContext.distDirectory, serverBase = _api_useAppContext.serverBase;
+                  runner = api.useHookRunners();
+                  config = api.useConfigContext();
+                  if (!routes) {
+                    return [
+                      2
+                    ];
+                  }
+                  customServer = new CustomServer(runner, serverBase, pwd);
+                  serverMiddleware = ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.middleware) && getServerMidFromUnstableMid(config.render.middleware);
+                  pageRoutes = getPageRoutes(routes);
+                  return [
+                    4,
+                    getRenderHandler({
+                      pwd,
+                      routes,
+                      config,
+                      metaName,
+                      cacheConfig: ((_config_render1 = config.render) === null || _config_render1 === void 0 ? void 0 : _config_render1.cache) || cacheConfig,
+                      staticGenerate
+                    })
+                  ];
+                case 1:
+                  render = _state.sent();
+                  _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+                  _state.label = 2;
+                case 2:
+                  _state.trys.push([
+                    2,
+                    8,
+                    9,
+                    10
+                  ]);
+                  _iterator = pageRoutes[Symbol.iterator]();
+                  _state.label = 3;
+                case 3:
+                  if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
+                    return [
+                      3,
+                      7
+                    ];
+                  route = _step.value;
+                  originUrlPath = route.urlPath, entryName = route.entryName;
+                  urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
+                  middlewares.push({
+                    name: "init-reporter",
+                    handler: initReporter(entryName || MAIN_ENTRY_NAME)
+                  });
+                  customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
+                  middlewares.push({
+                    name: "custom-server-hook",
+                    path: urlPath,
+                    handler: customServerHookMiddleware
+                  });
+                  _tmp = serverMiddleware;
+                  if (_tmp)
+                    return [
+                      3,
+                      5
+                    ];
+                  return [
+                    4,
+                    customServer.getServerMiddleware()
+                  ];
+                case 4:
+                  _tmp = _state.sent();
+                  _state.label = 5;
+                case 5:
+                  customServerMiddleware = _tmp;
+                  customServerMiddleware && middlewares.push({
+                    name: "custom-server-middleware",
+                    path: urlPath,
+                    handler: customServerMiddleware
+                  });
+                  middlewares.push({
+                    name: "render",
+                    path: urlPath,
+                    handler: createRenderHandler(render)
+                  });
+                  _state.label = 6;
+                case 6:
+                  _iteratorNormalCompletion = true;
+                  return [
+                    3,
+                    3
+                  ];
+                case 7:
+                  return [
+                    3,
+                    10
+                  ];
+                case 8:
+                  err = _state.sent();
+                  _didIteratorError = true;
+                  _iteratorError = err;
+                  return [
+                    3,
+                    10
+                  ];
+                case 9:
+                  try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                      _iterator.return();
+                    }
+                  } finally {
+                    if (_didIteratorError) {
+                      throw _iteratorError;
+                    }
+                  }
+                  return [
+                    7
+                  ];
+                case 10:
+                  return [
+                    2
+                  ];
+              }
+            });
+          })();
+        }
+      };
+    }
+  };
+};
+function getPageRoutes(routes) {
+  return routes.filter(function(route) {
+    return !route.isApi;
+  }).sort(sortRoutes);
+}
+function createRenderHandler(render) {
+  return function() {
+    var _ref = _async_to_generator(function(c, _) {
+      var _c_env_node, logger, reporter, templates, serverManifest, locals, metrics, loaderContext, request, nodeReq, res, body, status, headers, headersData;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            logger = c.get("logger");
+            reporter = c.get("reporter");
+            templates = c.get("templates") || {};
+            serverManifest = c.get("serverManifest") || {};
+            locals = c.get("locals");
+            metrics = c.get("metrics");
+            loaderContext = getLoaderCtx(c);
+            request = c.req.raw;
+            nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
+            return [
+              4,
+              render(request, {
+                logger,
+                nodeReq,
+                reporter,
+                templates,
+                metrics,
+                serverManifest,
+                loaderContext,
+                locals
+              })
+            ];
+          case 1:
+            res = _state.sent();
+            body = res.body, status = res.status, headers = res.headers;
+            headersData = {};
+            headers.forEach(function(v, k) {
+              headersData[k] = v;
+            });
+            return [
+              2,
+              c.body(body, status, headersData)
+            ];
+        }
+      });
+    });
+    return function(c, _) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+function getRenderHandler(_) {
+  return _getRenderHandler.apply(this, arguments);
+}
+function _getRenderHandler() {
+  _getRenderHandler = _async_to_generator(function(param) {
+    var pwd, routes, config, cacheConfig, metaName, staticGenerate, _config_server, _config_security, ssrConfig, forceCSR, render;
+    return _ts_generator(this, function(_state) {
+      pwd = param.pwd, routes = param.routes, config = param.config, cacheConfig = param.cacheConfig, metaName = param.metaName, staticGenerate = param.staticGenerate;
+      ssrConfig = (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr;
+      forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
+      render = createRender({
+        routes,
+        pwd,
+        // TODO: need static Genrate
+        staticGenerate,
+        cacheConfig,
+        forceCSR,
+        nonce: (_config_security = config.security) === null || _config_security === void 0 ? void 0 : _config_security.nonce,
+        metaName: metaName || "modern-js"
+      });
+      return [
+        2,
+        render
+      ];
+    });
+  });
+  return _getRenderHandler.apply(this, arguments);
+}
+export {
+  getRenderHandler,
+  renderPlugin
+};

package/dist/esm/{base/middlewares/renderHandler → plugins/render}/render.js

@@ -1,18 +1,30 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { cutNameByHyphen } from "@modern-js/utils/universal";
 import { TrieRouter } from "hono/router/trie-router";
 import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse, onError as onErrorFn, ErrorDigest } from "../../utils";
-import { REPLACE_REG } from "../../../base/constants";
+import { REPLACE_REG, X_MODERNJS_RENDER } from "../../constants";
 import { dataHandler } from "./dataHandler";
 import { ssrRender } from "./ssrRender";
+var DYNAMIC_ROUTE_REG = /\/:./;
 function getRouter(routes) {
-  var sorted = routes.sort(sortRoutes);
+  var dynamicRoutes = [];
+  var normalRoutes = [];
+  routes.forEach(function(route2) {
+    if (DYNAMIC_ROUTE_REG.test(route2.urlPath)) {
+      dynamicRoutes.push(route2);
+    } else {
+      normalRoutes.push(route2);
+    }
+  });
+  var finalRoutes = _to_consumable_array(normalRoutes.sort(sortRoutes)).concat(_to_consumable_array(dynamicRoutes.sort(sortRoutes)));
   var router = new TrieRouter();
   var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
   try {
-    for (var _iterator = sorted[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+    for (var _iterator = finalRoutes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
       var route = _step.value;
       var originUrlPath = route.urlPath;
       var urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
@@ -45,9 +57,9 @@ function createRender(_) {
 }
 function _createRender() {
   _createRender = _async_to_generator(function(param) {
-    var routes, pwd, metaName, staticGenerate, forceCSR, nonce, onFallbackFn, router;
+    var routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, nonce, onFallbackFn, router;
     return _ts_generator(this, function(_state) {
-      routes = param.routes, pwd = param.pwd, metaName = param.metaName, staticGenerate = param.staticGenerate, forceCSR = param.forceCSR, nonce = param.nonce, onFallbackFn = param.onFallback;
+      routes = param.routes, pwd = param.pwd, metaName = param.metaName, staticGenerate = param.staticGenerate, cacheConfig = param.cacheConfig, forceCSR = param.forceCSR, nonce = param.nonce, onFallbackFn = param.onFallback;
       router = getRouter(routes);
       return [
         2,
@@ -136,6 +148,7 @@ function _createRender() {
                     nonce,
                     logger,
                     nodeReq,
+                    cacheConfig,
                     reporter,
                     serverRoutes: routes,
                     params,
@@ -367,9 +380,9 @@ function _getRenderMode() {
 function csrRender(html) {
   return new Response(html, {
     status: 200,
-    headers: new Headers({
+    headers: new Headers(_define_property({
       "content-type": "text/html; charset=UTF-8"
-    })
+    }, X_MODERNJS_RENDER, "client"))
   });
 }
 function injectServerData(serverData) {