@modern-js/server-core 2.49.2 → 2.49.3

package/dist/cjs/base/adapters/node/bff.js

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

package/dist/cjs/base/adapters/node/middlewares/serverManifest.js

@@ -34,34 +34,34 @@ __export(serverManifest_exports, {
 module.exports = __toCommonJS(serverManifest_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
-async function getServerManifest(pwd, routes) {
+const dynamicImport = (filePath) => {
+  try {
+    const module2 = require(filePath);
+    return Promise.resolve(module2);
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+const loadBundle = async (filepath, logger) => {
+  if (!await import_utils.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 || import_utils.MAIN_ENTRY_NAME;
-    const loaderBundlePath = import_path.default.join(pwd, import_utils.SERVER_BUNDLE_DIRECTORY, `${entryName}-server-loaders.js`);
     const renderBundlePath = import_path.default.join(pwd, route.bundle || "");
-    const dynamicImport = (filePath) => {
-      try {
-        const module2 = require(filePath);
-        return Promise.resolve(module2);
-      } 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 = import_path.default.join(pwd, import_utils.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 = import_path.default.join(pwd, import_utils.LOADABLE_STATS_FILE);
   const loadableStats = await Promise.resolve().then(() => __toESM(require(loadableUri))).catch((_) => ({}));
@@ -77,7 +77,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/cjs/base/adapters/node/middlewares/serverPublic.js

@@ -47,6 +47,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/cjs/base/index.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var base_exports = {};
 __export(base_exports, {
   AGGRED_DIR: () => import_constants.AGGRED_DIR,
+  ErrorDigest: () => import_utils.ErrorDigest,
   bindRenderHandler: () => import_middlewares.bindRenderHandler,
   createErrorHtml: () => import_utils.createErrorHtml,
   createServerBase: () => import_serverBase.createServerBase,
@@ -27,6 +28,7 @@ __export(base_exports, {
   injectLogger: () => import_middlewares.injectLogger,
   injectReporter: () => import_middlewares.injectReporter,
   logHandler: () => import_middlewares.logHandler,
+  onError: () => import_utils.onError,
   processedBy: () => import_middlewares.processedBy
 });
 module.exports = __toCommonJS(base_exports);
@@ -37,6 +39,7 @@ var import_serverBase = require("./serverBase");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGGRED_DIR,
+  ErrorDigest,
   bindRenderHandler,
   createErrorHtml,
   createServerBase,
@@ -45,5 +48,6 @@ var import_serverBase = require("./serverBase");
   injectLogger,
   injectReporter,
   logHandler,
+  onError,
   processedBy
 });

package/dist/cjs/base/middlewares/customServer/context.js

@@ -43,13 +43,12 @@ function createCustomMiddlewaresCtx(c, locals) {
   var _c_env_node, _c_env_node1;
   const baseContext = (0, import_base.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/cjs/base/middlewares/renderHandler/index.js

@@ -59,8 +59,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;
@@ -71,7 +78,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;
   }
@@ -88,7 +96,7 @@ async function bindRenderHandler(server, options) {
       await ssrCache.loadCacheMod((0, import_utils.checkIsProd)() ? pwd : void 0);
     }
     const pageRoutes = routes.filter((route) => !route.isApi).sort(import_utils.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}/*`;

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

@@ -22,13 +22,38 @@ __export(render_exports, {
 });
 module.exports = __toCommonJS(render_exports);
 var import_universal = require("@modern-js/utils/universal");
+var import_trie_router = require("hono/router/trie-router");
 var import_constants = require("../../../base/constants");
 var import_utils = require("../../utils");
 var import_dataHandler = require("./dataHandler");
 var import_ssrRender = require("./ssrRender");
-async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce }) {
+function getRouter(routes) {
+  const sorted = routes.sort(import_utils.sortRoutes);
+  const router = new import_trie_router.TrieRouter();
+  for (const route of sorted) {
+    const { urlPath: originUrlPath } = route;
+    const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
+    router.add("*", urlPath, route);
+  }
+  return router;
+}
+function matchRoute(router, request) {
+  const pathname = (0, import_utils.getPathname)(request);
+  const matched = router.match("*", pathname);
+  const result = matched[0][0];
+  return result || [];
+}
+async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce, onFallback: onFallbackFn }) {
+  const router = getRouter(routes);
   return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals, metrics }) => {
-    const routeInfo = matchRoute(req, routes);
+    const [routeInfo, params] = matchRoute(router, req);
+    const onFallback = async (reason, error) => {
+      return onFallbackFn === null || onFallbackFn === void 0 ? void 0 : onFallbackFn(reason, {
+        logger,
+        reporter,
+        metrics
+      }, error);
+    };
     if (!routeInfo) {
       return new Response((0, import_utils.createErrorHtml)(404), {
         status: 404,
@@ -46,7 +71,11 @@ async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, n
         }
       });
     }
-    const renderMode = getRenderMode(req, metaName || "modern-js", routeInfo.isSSR, forceCSR, nodeReq);
+    const renderMode = await getRenderMode(req, metaName || "modern-js", routeInfo.isSSR, forceCSR, nodeReq, onFallback);
+    const onError = async (e) => {
+      (0, import_utils.onError)(logger, import_utils.ErrorDigest.ERENDER, e, req);
+      await (onFallback === null || onFallback === void 0 ? void 0 : onFallback("error", e));
+    };
     const renderOptions = {
       pwd,
       html,
@@ -58,6 +87,7 @@ async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, n
       nodeReq,
       reporter,
       serverRoutes: routes,
+      params,
       locals,
       serverManifest,
       metrics
@@ -66,38 +96,46 @@ async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, n
       case "data":
         let response = await (0, import_dataHandler.dataHandler)(req, renderOptions);
         if (!response) {
-          response = await renderHandler(req, renderOptions, "ssr");
+          response = await renderHandler(req, renderOptions, "ssr", onError);
         }
         return response;
       case "ssr":
       case "csr":
-        return renderHandler(req, renderOptions, renderMode);
+        return renderHandler(req, renderOptions, renderMode, onError);
       default:
         throw new Error(`Unknown render mode: ${renderMode}`);
     }
   };
 }
-async function renderHandler(request, options, mode) {
+async function renderHandler(request, options, mode, onError) {
   const serverData = {
     router: {
       baseUrl: options.routeInfo.urlPath,
-      params: {}
+      params: options.params
     }
   };
-  const response = await (mode === "ssr" ? (0, import_ssrRender.ssrRender)(request, options) : csrRender(options.html));
-  return (0, import_utils.transformResponse)(response, injectServerData(serverData));
-}
-function matchRoute(req, routes) {
-  const sorted = routes.sort(import_utils.sortRoutes);
-  for (const route of sorted) {
-    const pathname = (0, import_utils.getPathname)(req);
-    if (pathname.startsWith(route.urlPath)) {
-      return route;
+  let response;
+  if (mode === "ssr") {
+    try {
+      response = await (0, import_ssrRender.ssrRender)(request, options);
+    } catch (e) {
+      await onError(e);
+      response = csrRender(options.html);
     }
+  } else {
+    response = csrRender(options.html);
+  }
+  const newRes = (0, import_utils.transformResponse)(response, injectServerData(serverData));
+  const { routeInfo } = options;
+  applyExtendHeaders(newRes, routeInfo);
+  return newRes;
+  function applyExtendHeaders(r, route) {
+    Object.entries(route.responseHeaders || {}).forEach(([k, v]) => {
+      r.headers.set(k, v);
+    });
   }
-  return void 0;
 }
-function getRenderMode(req, framework, isSSR, forceCSR, nodeReq) {
+async function getRenderMode(req, framework, isSSR, forceCSR, nodeReq, onFallback) {
   const query = (0, import_utils.parseQuery)(req);
   const fallbackHeader = `x-${(0, import_universal.cutNameByHyphen)(framework)}-ssr-fallback`;
   if (isSSR) {
@@ -105,6 +143,11 @@ function getRenderMode(req, framework, isSSR, forceCSR, nodeReq) {
       return "data";
     }
     if (forceCSR && (query.csr || req.headers.get(fallbackHeader) || (nodeReq === null || nodeReq === void 0 ? void 0 : nodeReq.headers[fallbackHeader]))) {
+      if (query.csr) {
+        await (onFallback === null || onFallback === void 0 ? void 0 : onFallback("query"));
+      } else {
+        await (onFallback === null || onFallback === void 0 ? void 0 : onFallback("header"));
+      }
       return "csr";
     }
     return "ssr";

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

@@ -49,7 +49,7 @@ const defaultReporter = {
   reportWarn() {
   }
 };
-async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, metrics }) {
+async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics }) {
   var _serverManifest_renderBundles;
   const { entryName } = routeInfo;
   const loadableStats = serverManifest.loadableStats || {};
@@ -69,7 +69,7 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
   const ssrContext = {
     request: {
       baseUrl: routeInfo.urlPath,
-      params: {},
+      params,
       pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : (0, import_utils.getPathname)(request),
       host,
       query,

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

@@ -18,7 +18,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var error_exports = {};
 __export(error_exports, {
-  createErrorHtml: () => createErrorHtml
+  ErrorDigest: () => ErrorDigest,
+  createErrorHtml: () => createErrorHtml,
+  onError: () => onError
 });
 module.exports = __toCommonJS(error_exports);
 const ERROR_PAGE_TEXT = {
@@ -59,7 +61,20 @@ const createErrorHtml = (status) => {
   </html>
   `;
 };
+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) {
+  const 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 - ${digest}, error = %s, req.url = %s, req.headers = %o` : `Server Error - ${digest}, error = %s`, error instanceof Error ? error.stack || error.message : error, req === null || req === void 0 ? void 0 : req.url, headers);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createErrorHtml
+  ErrorDigest,
+  createErrorHtml,
+  onError
 });

package/dist/cjs/core/plugin.js

@@ -33,6 +33,7 @@ const gather = (0, import_plugin.createParallelWorkflow)();
 const config = (0, import_plugin.createWaterfall)();
 const prepare = (0, import_plugin.createWaterfall)();
 const prepareWebServer = (0, import_plugin.createAsyncPipeline)();
+const fallback = (0, import_plugin.createParallelWorkflow)();
 const prepareApiServer = (0, import_plugin.createAsyncPipeline)();
 const onApiChange = (0, import_plugin.createAsyncWaterfall)();
 const repack = (0, import_plugin.createWaterfall)();
@@ -56,6 +57,7 @@ const serverHooks = {
   gather,
   config,
   prepare,
+  fallback,
   prepareWebServer,
   prepareApiServer,
   repack,

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

@@ -74,7 +74,7 @@ var bindBFFHandler = function() {
             ];
           return [
             4,
-            getRenderHandler(options)
+            getRenderHandler(options, server)
           ];
         case 4:
           _tmp = _state.sent();

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

@@ -1,12 +1,51 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
-import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY } from "@modern-js/utils";
-function getServerManifest(pwd, routes) {
+import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, fs } from "@modern-js/utils";
+var dynamicImport = function(filePath) {
+  try {
+    var module = require(filePath);
+    return Promise.resolve(module);
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+var loadBundle = function() {
+  var _ref = _async_to_generator(function(filepath, logger) {
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            fs.pathExists(filepath)
+          ];
+        case 1:
+          if (!_state.sent()) {
+            return [
+              2,
+              void 0
+            ];
+          }
+          return [
+            2,
+            dynamicImport(filepath).catch(function(e) {
+              logger.error("Load ".concat(filepath, " bundle failed, error = %s"), _instanceof(e, Error) ? e.stack || e.message : e);
+              return void 0;
+            })
+          ];
+      }
+    });
+  });
+  return function loadBundle2(filepath, logger) {
+    return _ref.apply(this, arguments);
+  };
+}();
+function getServerManifest(pwd, routes, logger) {
   return _getServerManifest.apply(this, arguments);
 }
 function _getServerManifest() {
-  _getServerManifest = _async_to_generator(function(pwd, routes) {
+  _getServerManifest = _async_to_generator(function(pwd, routes, logger) {
     var loaderBundles, renderBundles, loadableUri, loadableStats, routesManifestUri, routeManifest;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
@@ -15,41 +54,31 @@ function _getServerManifest() {
           renderBundles = {};
           return [
             4,
-            Promise.all(routes.map(function() {
+            Promise.all(routes.filter(function(route) {
+              return Boolean(route.bundle);
+            }).map(function() {
               var _ref = _async_to_generator(function(route) {
-                var entryName, loaderBundlePath, renderBundlePath, dynamicImport;
+                var entryName, renderBundlePath, loaderBundlePath, renderBundle, loaderBundle;
                 return _ts_generator(this, function(_state2) {
                   switch (_state2.label) {
                     case 0:
                       entryName = route.entryName || MAIN_ENTRY_NAME;
-                      loaderBundlePath = path.join(pwd, SERVER_BUNDLE_DIRECTORY, "".concat(entryName, "-server-loaders.js"));
                       renderBundlePath = path.join(pwd, route.bundle || "");
-                      dynamicImport = function(filePath) {
-                        try {
-                          var module = require(filePath);
-                          return Promise.resolve(module);
-                        } catch (e) {
-                          return Promise.reject(e);
-                        }
-                      };
+                      loaderBundlePath = path.join(pwd, SERVER_BUNDLE_DIRECTORY, "".concat(entryName, "-server-loaders.js"));
                       return [
                         4,
-                        Promise.allSettled([
-                          dynamicImport(loaderBundlePath),
-                          dynamicImport(renderBundlePath)
-                        ]).then(function(results) {
-                          var _results_ = results[0], loaderStatus = _results_.status;
-                          if (loaderStatus === "fulfilled") {
-                            loaderBundles[entryName] = results[0].value;
-                          }
-                          var _results_1 = results[1], renderStatus = _results_1.status;
-                          if (renderStatus === "fulfilled") {
-                            renderBundles[entryName] = results[1].value;
-                          }
-                        })
+                        loadBundle(renderBundlePath, logger)
                       ];
                     case 1:
-                      _state2.sent();
+                      renderBundle = _state2.sent();
+                      return [
+                        4,
+                        loadBundle(loaderBundlePath, logger)
+                      ];
+                    case 2:
+                      loaderBundle = _state2.sent();
+                      renderBundle && (renderBundles[entryName] = renderBundle);
+                      loaderBundle && (loaderBundles[entryName] = loaderBundle);
                       return [
                         2
                       ];
@@ -98,7 +127,7 @@ function _getServerManifest() {
 function injectServerManifest(pwd, routes) {
   return function() {
     var _ref = _async_to_generator(function(c, next) {
-      var serverManifest;
+      var logger, serverManifest;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
@@ -107,9 +136,10 @@ function injectServerManifest(pwd, routes) {
                 3,
                 2
               ];
+            logger = c.get("logger");
             return [
               4,
-              getServerManifest(pwd, routes)
+              getServerManifest(pwd, routes, logger)
             ];
           case 1:
             serverManifest = _state.sent();

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

@@ -1,4 +1,5 @@
 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 path from "path";
 import { fileReader } from "@modern-js/runtime-utils/fileReader";
@@ -31,6 +32,10 @@ function createPublicMiddleware(param) {
               if (mimeType) {
                 c.header("Content-Type", mimeType);
               }
+              Object.entries(route.responseHeaders || {}).forEach(function(param2) {
+                var _param = _sliced_to_array(param2, 2), k = _param[0], v = _param[1];
+                c.header(k, v);
+              });
               return [
                 2,
                 c.body(data, 200)

package/dist/esm/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/base/middlewares/customServer/context.js

@@ -41,11 +41,11 @@ function createCustomMiddlewaresCtx(c, locals) {
   var _c_env_node, _c_env_node1;
   var baseContext = createBaseHookContext(c);
   var reporter = c.get("reporter");
+  var response = baseContext.response;
+  response.locals = locals;
   return _object_spread_props(_object_spread({}, baseContext), {
     reporter,
-    response: _object_spread_props(_object_spread({}, 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/base/middlewares/renderHandler/index.js

@@ -1,4 +1,5 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { checkIsProd, sortRoutes, getRuntimeEnv } from "../../utils";
 import { initReporter } from "../monitor";
@@ -45,14 +46,38 @@ function createRenderHandler(render) {
     };
   }();
 }
-function getRenderHandler(options) {
+function getRenderHandler(options, serverBase) {
   return _getRenderHandler.apply(this, arguments);
 }
 function _getRenderHandler() {
-  _getRenderHandler = _async_to_generator(function(options) {
-    var routes, pwd, config, _config_server, _options_config_security, ssrConfig, forceCSR, render;
+  _getRenderHandler = _async_to_generator(function(options, serverBase) {
+    var routes, pwd, config, onFallback, _config_server, _options_config_security, ssrConfig, forceCSR, render;
     return _ts_generator(this, function(_state) {
       routes = options.routes, pwd = options.pwd, config = options.config;
+      onFallback = function() {
+        var _ref = _async_to_generator(function(reason, utils, error) {
+          return _ts_generator(this, function(_state2) {
+            switch (_state2.label) {
+              case 0:
+                return [
+                  4,
+                  serverBase === null || serverBase === void 0 ? void 0 : serverBase.runner.fallback(_object_spread({
+                    reason,
+                    error
+                  }, utils))
+                ];
+              case 1:
+                _state2.sent();
+                return [
+                  2
+                ];
+            }
+          });
+        });
+        return function onFallback2(reason, utils, error) {
+          return _ref.apply(this, arguments);
+        };
+      }();
       if (routes && routes.length > 0) {
         ;
         ssrConfig = (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr;
@@ -63,7 +88,8 @@ function _getRenderHandler() {
           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 [
           2,
@@ -120,7 +146,7 @@ function _bindRenderHandler() {
           }).sort(sortRoutes);
           return [
             4,
-            getRenderHandler(options)
+            getRenderHandler(options, server)
           ];
         case 4:
           render = _state.sent();