@modern-js/server-core 2.49.2 → 2.49.3

package/dist/esm/base/middlewares/renderHandler/render.js

@@ -1,28 +1,81 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_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 { REPLACE_REG } from "../../../base/constants";
-import { createErrorHtml, sortRoutes, parseQuery, transformResponse, getPathname } from "../../utils";
+import { createErrorHtml, sortRoutes, parseQuery, transformResponse, getPathname, onError as onErrorFn, ErrorDigest } from "../../utils";
 import { dataHandler } from "./dataHandler";
 import { ssrRender } from "./ssrRender";
+function getRouter(routes) {
+  var sorted = routes.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) {
+      var route = _step.value;
+      var originUrlPath = route.urlPath;
+      var urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
+      router.add("*", urlPath, route);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return router;
+}
+function matchRoute(router, request) {
+  var pathname = getPathname(request);
+  var matched = router.match("*", pathname);
+  var result = matched[0][0];
+  return result || [];
+}
 function createRender(_) {
   return _createRender.apply(this, arguments);
 }
 function _createRender() {
   _createRender = _async_to_generator(function(param) {
-    var routes, pwd, metaName, staticGenerate, forceCSR, nonce;
+    var routes, pwd, metaName, staticGenerate, 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;
+      routes = param.routes, pwd = param.pwd, metaName = param.metaName, staticGenerate = param.staticGenerate, forceCSR = param.forceCSR, nonce = param.nonce, onFallbackFn = param.onFallback;
+      router = getRouter(routes);
       return [
         2,
         function() {
           var _ref = _async_to_generator(function(req, param2) {
-            var logger, nodeReq, reporter, templates, serverManifest, locals, metrics, routeInfo, html, renderMode, renderOptions, response;
+            var logger, nodeReq, reporter, templates, serverManifest, locals, metrics, _matchRoute, routeInfo, params, onFallback, html, renderMode, onError, renderOptions, response;
             return _ts_generator(this, function(_state2) {
               switch (_state2.label) {
                 case 0:
                   logger = param2.logger, nodeReq = param2.nodeReq, reporter = param2.reporter, templates = param2.templates, serverManifest = param2.serverManifest, locals = param2.locals, metrics = param2.metrics;
-                  routeInfo = matchRoute(req, routes);
+                  _matchRoute = _sliced_to_array(matchRoute(router, req), 2), routeInfo = _matchRoute[0], params = _matchRoute[1];
+                  onFallback = function() {
+                    var _ref2 = _async_to_generator(function(reason, error) {
+                      return _ts_generator(this, function(_state3) {
+                        return [
+                          2,
+                          onFallbackFn === null || onFallbackFn === void 0 ? void 0 : onFallbackFn(reason, {
+                            logger,
+                            reporter,
+                            metrics
+                          }, error)
+                        ];
+                      });
+                    });
+                    return function onFallback2(reason, error) {
+                      return _ref2.apply(this, arguments);
+                    };
+                  }();
                   if (!routeInfo) {
                     return [
                       2,
@@ -46,7 +99,34 @@ function _createRender() {
                       })
                     ];
                   }
-                  renderMode = getRenderMode(req, metaName || "modern-js", routeInfo.isSSR, forceCSR, nodeReq);
+                  return [
+                    4,
+                    getRenderMode(req, metaName || "modern-js", routeInfo.isSSR, forceCSR, nodeReq, onFallback)
+                  ];
+                case 1:
+                  renderMode = _state2.sent();
+                  onError = function() {
+                    var _ref2 = _async_to_generator(function(e) {
+                      return _ts_generator(this, function(_state3) {
+                        switch (_state3.label) {
+                          case 0:
+                            onErrorFn(logger, ErrorDigest.ERENDER, e, req);
+                            return [
+                              4,
+                              onFallback === null || onFallback === void 0 ? void 0 : onFallback("error", e)
+                            ];
+                          case 1:
+                            _state3.sent();
+                            return [
+                              2
+                            ];
+                        }
+                      });
+                    });
+                    return function onError2(e) {
+                      return _ref2.apply(this, arguments);
+                    };
+                  }();
                   renderOptions = {
                     pwd,
                     html,
@@ -58,6 +138,7 @@ function _createRender() {
                     nodeReq,
                     reporter,
                     serverRoutes: routes,
+                    params,
                     locals,
                     serverManifest,
                     metrics
@@ -66,55 +147,55 @@ function _createRender() {
                     case "data":
                       return [
                         3,
-                        1
+                        2
                       ];
                     case "ssr":
                       return [
                         3,
-                        5
+                        6
                       ];
                     case "csr":
                       return [
                         3,
-                        5
+                        6
                       ];
                   }
                   return [
                     3,
-                    6
+                    7
                   ];
-                case 1:
+                case 2:
                   return [
                     4,
                     dataHandler(req, renderOptions)
                   ];
-                case 2:
+                case 3:
                   response = _state2.sent();
                   if (!!response)
                     return [
                       3,
-                      4
+                      5
                     ];
                   return [
                     4,
-                    renderHandler(req, renderOptions, "ssr")
+                    renderHandler(req, renderOptions, "ssr", onError)
                   ];
-                case 3:
-                  response = _state2.sent();
-                  _state2.label = 4;
                 case 4:
+                  response = _state2.sent();
+                  _state2.label = 5;
+                case 5:
                   return [
                     2,
                     response
                   ];
-                case 5:
+                case 6:
                   return [
                     2,
-                    renderHandler(req, renderOptions, renderMode)
+                    renderHandler(req, renderOptions, renderMode, onError)
                   ];
-                case 6:
-                  throw new Error("Unknown render mode: ".concat(renderMode));
                 case 7:
+                  throw new Error("Unknown render mode: ".concat(renderMode));
+                case 8:
                   return [
                     2
                   ];
@@ -130,77 +211,157 @@ function _createRender() {
   });
   return _createRender.apply(this, arguments);
 }
-function renderHandler(request, options, mode) {
+function renderHandler(request, options, mode, onError) {
   return _renderHandler.apply(this, arguments);
 }
 function _renderHandler() {
-  _renderHandler = _async_to_generator(function(request, options, mode) {
-    var serverData, response;
+  _renderHandler = _async_to_generator(function(request, options, mode, onError) {
+    var serverData, response, e, newRes, routeInfo;
+    function applyExtendHeaders(r, route) {
+      Object.entries(route.responseHeaders || {}).forEach(function(param) {
+        var _param = _sliced_to_array(param, 2), k = _param[0], v = _param[1];
+        r.headers.set(k, v);
+      });
+    }
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
           serverData = {
             router: {
               baseUrl: options.routeInfo.urlPath,
-              params: {}
+              params: options.params
             }
           };
+          if (!(mode === "ssr"))
+            return [
+              3,
+              6
+            ];
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            3,
+            ,
+            5
+          ]);
           return [
             4,
-            mode === "ssr" ? ssrRender(request, options) : csrRender(options.html)
+            ssrRender(request, options)
           ];
-        case 1:
+        case 2:
           response = _state.sent();
+          return [
+            3,
+            5
+          ];
+        case 3:
+          e = _state.sent();
+          return [
+            4,
+            onError(e)
+          ];
+        case 4:
+          _state.sent();
+          response = csrRender(options.html);
+          return [
+            3,
+            5
+          ];
+        case 5:
+          return [
+            3,
+            7
+          ];
+        case 6:
+          response = csrRender(options.html);
+          _state.label = 7;
+        case 7:
+          newRes = transformResponse(response, injectServerData(serverData));
+          routeInfo = options.routeInfo;
+          applyExtendHeaders(newRes, routeInfo);
           return [
             2,
-            transformResponse(response, injectServerData(serverData))
+            newRes
           ];
       }
     });
   });
   return _renderHandler.apply(this, arguments);
 }
-function matchRoute(req, routes) {
-  var sorted = routes.sort(sortRoutes);
-  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-  try {
-    for (var _iterator = sorted[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-      var route = _step.value;
-      var pathname = getPathname(req);
-      if (pathname.startsWith(route.urlPath)) {
-        return route;
-      }
-    }
-  } catch (err) {
-    _didIteratorError = true;
-    _iteratorError = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion && _iterator.return != null) {
-        _iterator.return();
-      }
-    } finally {
-      if (_didIteratorError) {
-        throw _iteratorError;
-      }
-    }
-  }
-  return void 0;
+function getRenderMode(req, framework, isSSR, forceCSR, nodeReq, onFallback) {
+  return _getRenderMode.apply(this, arguments);
 }
-function getRenderMode(req, framework, isSSR, forceCSR, nodeReq) {
-  var query = parseQuery(req);
-  var fallbackHeader = "x-".concat(cutNameByHyphen(framework), "-ssr-fallback");
-  if (isSSR) {
-    if (query.__loader) {
-      return "data";
-    }
-    if (forceCSR && (query.csr || req.headers.get(fallbackHeader) || (nodeReq === null || nodeReq === void 0 ? void 0 : nodeReq.headers[fallbackHeader]))) {
-      return "csr";
-    }
-    return "ssr";
-  } else {
-    return "csr";
-  }
+function _getRenderMode() {
+  _getRenderMode = _async_to_generator(function(req, framework, isSSR, forceCSR, nodeReq, onFallback) {
+    var query, fallbackHeader;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          query = parseQuery(req);
+          fallbackHeader = "x-".concat(cutNameByHyphen(framework), "-ssr-fallback");
+          if (!isSSR)
+            return [
+              3,
+              6
+            ];
+          if (query.__loader) {
+            return [
+              2,
+              "data"
+            ];
+          }
+          if (!(forceCSR && (query.csr || req.headers.get(fallbackHeader) || (nodeReq === null || nodeReq === void 0 ? void 0 : nodeReq.headers[fallbackHeader]))))
+            return [
+              3,
+              5
+            ];
+          if (!query.csr)
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            onFallback === null || onFallback === void 0 ? void 0 : onFallback("query")
+          ];
+        case 1:
+          _state.sent();
+          return [
+            3,
+            4
+          ];
+        case 2:
+          return [
+            4,
+            onFallback === null || onFallback === void 0 ? void 0 : onFallback("header")
+          ];
+        case 3:
+          _state.sent();
+          _state.label = 4;
+        case 4:
+          return [
+            2,
+            "csr"
+          ];
+        case 5:
+          return [
+            2,
+            "ssr"
+          ];
+        case 6:
+          return [
+            2,
+            "csr"
+          ];
+        case 7:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _getRenderMode.apply(this, arguments);
 }
 function csrRender(html) {
   return new Response(html, {

package/dist/esm/base/middlewares/renderHandler/ssrRender.js

@@ -24,11 +24,11 @@ function ssrRender(request, _) {
 }
 function _ssrRender() {
   _ssrRender = _async_to_generator(function(request, param) {
-    var routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, metrics, _serverManifest_renderBundles, entryName, loadableStats, routeManifest, host, isSpider, responseProxy, query, headers, key, ssrContext, renderBundle, runtimeEnv, ssrResult, cacheStatus, render, cacheModuleName, ssrCache, incomingMessage, cacheControl, _ref, data, status, redirection, headers1, Readable, streamModule, createReadableStreamFromReadable, _tmp, data1;
+    var routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, _serverManifest_renderBundles, entryName, loadableStats, routeManifest, host, isSpider, responseProxy, query, headers, key, ssrContext, renderBundle, runtimeEnv, ssrResult, cacheStatus, render, cacheModuleName, ssrCache, incomingMessage, cacheControl, _ref, data, status, redirection, headers1, Readable, streamModule, createReadableStreamFromReadable, _tmp, data1;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          routeInfo = param.routeInfo, html = param.html, staticGenerate = param.staticGenerate, nonce = param.nonce, metaName = param.metaName, reporter = param.reporter, logger = param.logger, nodeReq = param.nodeReq, serverManifest = param.serverManifest, locals = param.locals, metrics = param.metrics;
+          routeInfo = param.routeInfo, html = param.html, staticGenerate = param.staticGenerate, nonce = param.nonce, metaName = param.metaName, reporter = param.reporter, logger = param.logger, nodeReq = param.nodeReq, serverManifest = param.serverManifest, locals = param.locals, params = param.params, metrics = param.metrics;
           entryName = routeInfo.entryName;
           loadableStats = serverManifest.loadableStats || {};
           routeManifest = serverManifest.routeManifest || {};
@@ -47,7 +47,7 @@ function _ssrRender() {
           ssrContext = {
             request: {
               baseUrl: routeInfo.urlPath,
-              params: {},
+              params,
               pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : getPathname(request),
               host,
               query,

package/dist/esm/base/utils/error.js

@@ -1,3 +1,4 @@
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
 var ERROR_PAGE_TEXT = {
   404: "This page could not be found.",
   500: "Internal Server Error."
@@ -7,6 +8,19 @@ var createErrorHtml = function(status) {
   var title = "".concat(status, ": ").concat(text);
   return '<!DOCTYPE html>\n  <html lang="en">\n  <head>\n    <meta charset="utf-8">\n    <meta name="viewport" content="width=device-width">\n    <title>'.concat(title, '</title>\n    <style>\n      html,body {\n        margin: 0;\n      }\n\n      .page-container {\n        color: #000;\n        background: #fff;\n        height: 100vh;\n        text-align: center;\n        display: flex;\n        flex-direction: column;\n        align-items: center;\n        justify-content: center;\n      }\n    </style>\n  </head>\n  <body>\n    <div class="page-container">\n    <h1>').concat(status, "</h1>\n    <div>").concat(text, "</div>\n  </body>\n  </html>\n  ");
 };
+var ErrorDigest;
+(function(ErrorDigest2) {
+  ErrorDigest2["ENOTF"] = "Page could not be found";
+  ErrorDigest2["EINTER"] = "Internal server error";
+  ErrorDigest2["ERENDER"] = "SSR render failed";
+})(ErrorDigest || (ErrorDigest = {}));
+function onError(logger, digest, error, req) {
+  var headers = req === null || req === void 0 ? void 0 : req.headers;
+  headers === null || headers === void 0 ? void 0 : headers.delete("cookie");
+  logger.error(req ? "Server Error - ".concat(digest, ", error = %s, req.url = %s, req.headers = %o") : "Server Error - ".concat(digest, ", error = %s"), _instanceof(error, Error) ? error.stack || error.message : error, req === null || req === void 0 ? void 0 : req.url, headers);
+}
 export {
-  createErrorHtml
+  ErrorDigest,
+  createErrorHtml,
+  onError
 };

package/dist/esm/core/plugin.js

@@ -3,6 +3,7 @@ var gather = createParallelWorkflow();
 var config = createWaterfall();
 var prepare = createWaterfall();
 var prepareWebServer = createAsyncPipeline();
+var fallback = createParallelWorkflow();
 var prepareApiServer = createAsyncPipeline();
 var onApiChange = createAsyncWaterfall();
 var repack = createWaterfall();
@@ -32,6 +33,7 @@ var serverHooks = {
   gather,
   config,
   prepare,
+  fallback,
   prepareWebServer,
   prepareApiServer,
   repack,

package/dist/esm-node/base/adapters/node/bff.js

@@ -21,7 +21,7 @@ const bindBFFHandler = async (server, options) => {
       await next();
     };
   } else {
-    const renderHandler = enableHandleWeb ? await getRenderHandler(options) : null;
+    const renderHandler = enableHandleWeb ? await getRenderHandler(options, server) : null;
     handler = await server.runner.prepareApiServer({
       pwd: options.pwd,
       prefix,

package/dist/esm-node/base/adapters/node/middlewares/serverManifest.js

@@ -1,33 +1,33 @@
 import path from "path";
-import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY } from "@modern-js/utils";
-async function getServerManifest(pwd, routes) {
+import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, fs } from "@modern-js/utils";
+const dynamicImport = (filePath) => {
+  try {
+    const module = require(filePath);
+    return Promise.resolve(module);
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+const loadBundle = async (filepath, logger) => {
+  if (!await fs.pathExists(filepath)) {
+    return void 0;
+  }
+  return dynamicImport(filepath).catch((e) => {
+    logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
+    return void 0;
+  });
+};
+async function getServerManifest(pwd, routes, logger) {
   const loaderBundles = {};
   const renderBundles = {};
-  await Promise.all(routes.map(async (route) => {
+  await Promise.all(routes.filter((route) => Boolean(route.bundle)).map(async (route) => {
     const entryName = route.entryName || MAIN_ENTRY_NAME;
-    const loaderBundlePath = path.join(pwd, SERVER_BUNDLE_DIRECTORY, `${entryName}-server-loaders.js`);
     const renderBundlePath = path.join(pwd, route.bundle || "");
-    const dynamicImport = (filePath) => {
-      try {
-        const module = require(filePath);
-        return Promise.resolve(module);
-      } catch (e) {
-        return Promise.reject(e);
-      }
-    };
-    await Promise.allSettled([
-      dynamicImport(loaderBundlePath),
-      dynamicImport(renderBundlePath)
-    ]).then((results) => {
-      const { status: loaderStatus } = results[0];
-      if (loaderStatus === "fulfilled") {
-        loaderBundles[entryName] = results[0].value;
-      }
-      const { status: renderStatus } = results[1];
-      if (renderStatus === "fulfilled") {
-        renderBundles[entryName] = results[1].value;
-      }
-    });
+    const loaderBundlePath = path.join(pwd, SERVER_BUNDLE_DIRECTORY, `${entryName}-server-loaders.js`);
+    const renderBundle = await loadBundle(renderBundlePath, logger);
+    const loaderBundle = await loadBundle(loaderBundlePath, logger);
+    renderBundle && (renderBundles[entryName] = renderBundle);
+    loaderBundle && (loaderBundles[entryName] = loaderBundle);
   }));
   const loadableUri = path.join(pwd, LOADABLE_STATS_FILE);
   const loadableStats = await import(loadableUri).catch((_) => ({}));
@@ -43,7 +43,8 @@ async function getServerManifest(pwd, routes) {
 function injectServerManifest(pwd, routes) {
   return async (c, next) => {
     if (routes && !c.get("serverManifest")) {
-      const serverManifest = await getServerManifest(pwd, routes);
+      const logger = c.get("logger");
+      const serverManifest = await getServerManifest(pwd, routes, logger);
       c.set("serverManifest", serverManifest);
     }
     await next();

package/dist/esm-node/base/adapters/node/middlewares/serverPublic.js

@@ -14,6 +14,9 @@ function createPublicMiddleware({ pwd, routes }) {
         if (mimeType) {
           c.header("Content-Type", mimeType);
         }
+        Object.entries(route.responseHeaders || {}).forEach(([k, v]) => {
+          c.header(k, v);
+        });
         return c.body(data, 200);
       }
     }

package/dist/esm-node/base/index.js

@@ -1,9 +1,10 @@
-import { createErrorHtml } from "./utils";
+import { createErrorHtml, onError, ErrorDigest } from "./utils";
 import { AGGRED_DIR } from "./constants";
 import { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy } from "./middlewares";
 import { createServerBase } from "./serverBase";
 export {
   AGGRED_DIR,
+  ErrorDigest,
   bindRenderHandler,
   createErrorHtml,
   createServerBase,
@@ -12,5 +13,6 @@ export {
   injectLogger,
   injectReporter,
   logHandler,
+  onError,
   processedBy
 };

package/dist/esm-node/base/middlewares/customServer/context.js

@@ -17,13 +17,12 @@ function createCustomMiddlewaresCtx(c, locals) {
   var _c_env_node, _c_env_node1;
   const baseContext = createBaseHookContext(c);
   const reporter = c.get("reporter");
+  const response = baseContext.response;
+  response.locals = locals;
   return {
     ...baseContext,
     reporter,
-    response: {
-      ...baseContext.response,
-      locals
-    },
+    response,
     source: {
       req: (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req,
       res: (_c_env_node1 = c.env.node) === null || _c_env_node1 === void 0 ? void 0 : _c_env_node1.res

package/dist/esm-node/base/middlewares/renderHandler/index.js

@@ -25,8 +25,15 @@ function createRenderHandler(render) {
     return res;
   };
 }
-async function getRenderHandler(options) {
+async function getRenderHandler(options, serverBase) {
   const { routes, pwd, config } = options;
+  const onFallback = async (reason, utils, error) => {
+    await (serverBase === null || serverBase === void 0 ? void 0 : serverBase.runner.fallback({
+      reason,
+      error,
+      ...utils
+    }));
+  };
   if (routes && routes.length > 0) {
     var _config_server, _options_config_security;
     const ssrConfig = (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr;
@@ -37,7 +44,8 @@ async function getRenderHandler(options) {
       staticGenerate: options.staticGenerate,
       metaName: options.metaName || "modern-js",
       forceCSR,
-      nonce: (_options_config_security = options.config.security) === null || _options_config_security === void 0 ? void 0 : _options_config_security.nonce
+      nonce: (_options_config_security = options.config.security) === null || _options_config_security === void 0 ? void 0 : _options_config_security.nonce,
+      onFallback
     });
     return render;
   }
@@ -54,7 +62,7 @@ async function bindRenderHandler(server, options) {
       await ssrCache.loadCacheMod(checkIsProd() ? pwd : void 0);
     }
     const pageRoutes = routes.filter((route) => !route.isApi).sort(sortRoutes);
-    const render = await getRenderHandler(options);
+    const render = await getRenderHandler(options, server);
     for (const route of pageRoutes) {
       const { urlPath: originUrlPath, entryName } = route;
       const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;