@modern-js/server-core 2.49.2 → 2.49.3

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

@@ -1,11 +1,36 @@
 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";
-async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce }) {
+function getRouter(routes) {
+  const sorted = routes.sort(sortRoutes);
+  const router = new 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 = 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(createErrorHtml(404), {
         status: 404,
@@ -23,7 +48,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) => {
+      onErrorFn(logger, ErrorDigest.ERENDER, e, req);
+      await (onFallback === null || onFallback === void 0 ? void 0 : onFallback("error", e));
+    };
     const renderOptions = {
       pwd,
       html,
@@ -35,6 +64,7 @@ async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, n
       nodeReq,
       reporter,
       serverRoutes: routes,
+      params,
       locals,
       serverManifest,
       metrics
@@ -43,38 +73,46 @@ async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, n
       case "data":
         let response = await 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" ? ssrRender(request, options) : csrRender(options.html));
-  return transformResponse(response, injectServerData(serverData));
-}
-function matchRoute(req, routes) {
-  const sorted = routes.sort(sortRoutes);
-  for (const route of sorted) {
-    const pathname = getPathname(req);
-    if (pathname.startsWith(route.urlPath)) {
-      return route;
+  let response;
+  if (mode === "ssr") {
+    try {
+      response = await ssrRender(request, options);
+    } catch (e) {
+      await onError(e);
+      response = csrRender(options.html);
     }
+  } else {
+    response = csrRender(options.html);
+  }
+  const newRes = 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 = parseQuery(req);
   const fallbackHeader = `x-${cutNameByHyphen(framework)}-ssr-fallback`;
   if (isSSR) {
@@ -82,6 +120,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/esm-node/base/middlewares/renderHandler/ssrRender.js

@@ -15,7 +15,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 || {};
@@ -35,7 +35,7 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
   const ssrContext = {
     request: {
       baseUrl: routeInfo.urlPath,
-      params: {},
+      params,
       pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : getPathname(request),
       host,
       query,

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

@@ -36,6 +36,19 @@ 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);
+}
 export {
-  createErrorHtml
+  ErrorDigest,
+  createErrorHtml,
+  onError
 };

package/dist/esm-node/core/plugin.js

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

package/dist/types/base/adapters/node/middlewares/serverManifest.d.ts

@@ -1,4 +1,4 @@
-import type { ServerRoute } from '@modern-js/types';
+import type { ServerRoute, Logger } from '@modern-js/types';
 import { Middleware, ServerEnv, ServerManifest } from '../../../../core/server';
-export declare function getServerManifest(pwd: string, routes: ServerRoute[]): Promise<ServerManifest>;
+export declare function getServerManifest(pwd: string, routes: ServerRoute[], logger: Logger): Promise<ServerManifest>;
 export declare function injectServerManifest(pwd: string, routes?: ServerRoute[]): Middleware<ServerEnv>;

package/dist/types/base/index.d.ts

@@ -1,4 +1,4 @@
-export { createErrorHtml } from './utils';
+export { createErrorHtml, onError, ErrorDigest } from './utils';
 export { AGGRED_DIR } from './constants';
 export { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy, } from './middlewares';
 export type { BindRenderHandleOptions } from './middlewares';

package/dist/types/base/middlewares/renderHandler/index.d.ts

@@ -5,5 +5,5 @@ export type BindRenderHandleOptions = {
     staticGenerate?: boolean;
     disableCustomHook?: boolean;
 };
-export declare function getRenderHandler(options: ServerBaseOptions & BindRenderHandleOptions): Promise<Render | null>;
+export declare function getRenderHandler(options: ServerBaseOptions & BindRenderHandleOptions, serverBase?: ServerBase): Promise<Render | null>;
 export declare function bindRenderHandler(server: ServerBase, options: ServerBaseOptions & BindRenderHandleOptions): Promise<void>;

package/dist/types/base/middlewares/renderHandler/render.d.ts

@@ -1,12 +1,19 @@
-import { ServerRoute } from '@modern-js/types';
+import { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
+import type { FallbackReason } from '../../../core/plugin';
 import { Render } from '../../../core/render';
+export type OnFallback = (reason: FallbackReason, utils: {
+    logger: Logger;
+    metrics?: Metrics;
+    reporter?: Reporter;
+}, error?: unknown) => Promise<void>;
 interface CreateRenderOptions {
     routes: ServerRoute[];
     pwd: string;
     staticGenerate?: boolean;
+    onFallback?: OnFallback;
     metaName?: string;
     forceCSR?: boolean;
     nonce?: string;
 }
-export declare function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce, }: CreateRenderOptions): Promise<Render>;
+export declare function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce, onFallback: onFallbackFn, }: CreateRenderOptions): Promise<Render>;
 export {};

package/dist/types/base/middlewares/renderHandler/ssrRender.d.ts

@@ -2,6 +2,7 @@
 import type { IncomingMessage } from 'http';
 import type { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
 import { ServerManifest } from '../../../core/server';
+export type Params = Record<string, any>;
 export interface SSRRenderOptions {
     pwd: string;
     html: string;
@@ -10,6 +11,7 @@ export interface SSRRenderOptions {
     metaName: string;
     logger: Logger;
     serverManifest: ServerManifest;
+    params: Params;
     /** Produce by custom server hook */
     locals?: Record<string, any>;
     reporter?: Reporter;
@@ -17,5 +19,5 @@ export interface SSRRenderOptions {
     nodeReq?: IncomingMessage;
     nonce?: string;
 }
-export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, metrics, }: SSRRenderOptions): Promise<Response>;
+export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, }: SSRRenderOptions): Promise<Response>;
 export declare function getPathnameFromNodeReq(nodeReq: IncomingMessage): string;

package/dist/types/base/utils/error.d.ts

@@ -1 +1,8 @@
+import type { Logger } from '@modern-js/types';
 export declare const createErrorHtml: (status: number) => string;
+export declare enum ErrorDigest {
+    ENOTF = "Page could not be found",
+    EINTER = "Internal server error",
+    ERENDER = "SSR render failed"
+}
+export declare function onError(logger: Logger, digest: ErrorDigest, error: Error | string, req?: Request): void;

package/dist/types/core/plugin.d.ts

@@ -1,14 +1,13 @@
 /// <reference types="node" />
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { CommonAPI, ToThreads, AsyncSetup, PluginOptions, ToRunners } from '@modern-js/plugin';
-import type { ModernServerContext, AfterMatchContext, AfterRenderContext, MiddlewareContext, ISAppContext, HttpMethodDecider, ServerInitHookContext, AfterStreamingRenderContext } from '@modern-js/types';
+import type { ModernServerContext, AfterMatchContext, AfterRenderContext, MiddlewareContext, ISAppContext, HttpMethodDecider, ServerInitHookContext, AfterStreamingRenderContext, Logger, Metrics, Reporter } from '@modern-js/types';
 import { MiddlewareHandler as Middleware } from 'hono';
 import type { BffUserConfig, UserConfig } from '../types/config';
 import { Render } from './render';
 export type WebAdapter = (ctx: MiddlewareContext) => void | Promise<void>;
 export type NodeRequest = IncomingMessage;
 export type NodeResponse = ServerResponse;
-export type Adapter = (req: NodeRequest, res: NodeResponse) => void | Promise<void>;
 export type WebServerStartInput = {
     pwd: string;
     config: Record<string, any>;
@@ -27,6 +26,7 @@ type Change = {
     filename: string;
     event: 'add' | 'change' | 'unlink';
 };
+export type FallbackReason = 'error' | 'header' | 'query';
 export type Route = Record<string, unknown>;
 export type RequestResult = {
     isfinish: boolean;
@@ -56,6 +56,13 @@ declare const serverHooks: {
     }, unknown>;
     config: import("@modern-js/plugin").Waterfall<ServerConfig>;
     prepare: import("@modern-js/plugin").Waterfall<void>;
+    fallback: import("@modern-js/plugin").ParallelWorkflow<{
+        reason: FallbackReason;
+        error: unknown;
+        logger: Logger;
+        metrics?: Metrics | undefined;
+        reporter?: Reporter | undefined;
+    }, unknown>;
     prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
     prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
@@ -81,6 +88,13 @@ export declare const createServerManager: () => import("@modern-js/plugin").Asyn
     }, unknown>;
     config: import("@modern-js/plugin").Waterfall<ServerConfig>;
     prepare: import("@modern-js/plugin").Waterfall<void>;
+    fallback: import("@modern-js/plugin").ParallelWorkflow<{
+        reason: FallbackReason;
+        error: unknown;
+        logger: Logger;
+        metrics?: Metrics | undefined;
+        reporter?: Reporter | undefined;
+    }, unknown>;
     prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
     prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
@@ -102,6 +116,13 @@ export declare const serverManager: import("@modern-js/plugin").AsyncManager<{
     }, unknown>;
     config: import("@modern-js/plugin").Waterfall<ServerConfig>;
     prepare: import("@modern-js/plugin").Waterfall<void>;
+    fallback: import("@modern-js/plugin").ParallelWorkflow<{
+        reason: FallbackReason;
+        error: unknown;
+        logger: Logger;
+        metrics?: Metrics | undefined;
+        reporter?: Reporter | undefined;
+    }, unknown>;
     prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
     prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
@@ -129,6 +150,13 @@ export declare const createPlugin: (setup?: AsyncSetup<{
     }, unknown>;
     config: import("@modern-js/plugin").Waterfall<ServerConfig>;
     prepare: import("@modern-js/plugin").Waterfall<void>;
+    fallback: import("@modern-js/plugin").ParallelWorkflow<{
+        reason: FallbackReason;
+        error: unknown;
+        logger: Logger;
+        metrics?: Metrics | undefined;
+        reporter?: Reporter | undefined;
+    }, unknown>;
     prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
     prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
@@ -149,6 +177,13 @@ export declare const createPlugin: (setup?: AsyncSetup<{
     }, unknown>;
     config: import("@modern-js/plugin").Waterfall<ServerConfig>;
     prepare: import("@modern-js/plugin").Waterfall<void>;
+    fallback: import("@modern-js/plugin").ParallelWorkflow<{
+        reason: FallbackReason;
+        error: unknown;
+        logger: Logger;
+        metrics?: Metrics | undefined;
+        reporter?: Reporter | undefined;
+    }, unknown>;
     prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
     prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
@@ -165,6 +200,13 @@ export declare const createPlugin: (setup?: AsyncSetup<{
     }, unknown>;
     config: import("@modern-js/plugin").Waterfall<ServerConfig>;
     prepare: import("@modern-js/plugin").Waterfall<void>;
+    fallback: import("@modern-js/plugin").ParallelWorkflow<{
+        reason: FallbackReason;
+        error: unknown;
+        logger: Logger;
+        metrics?: Metrics | undefined;
+        reporter?: Reporter | undefined;
+    }, unknown>;
     prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
     prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
@@ -185,6 +227,13 @@ export declare const createPlugin: (setup?: AsyncSetup<{
     }, unknown>;
     config: import("@modern-js/plugin").Waterfall<ServerConfig>;
     prepare: import("@modern-js/plugin").Waterfall<void>;
+    fallback: import("@modern-js/plugin").ParallelWorkflow<{
+        reason: FallbackReason;
+        error: unknown;
+        logger: Logger;
+        metrics?: Metrics | undefined;
+        reporter?: Reporter | undefined;
+    }, unknown>;
     prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
     prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.49.2",
+  "version": "2.49.3",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -69,9 +69,9 @@
     "hono": "^3.12.2",
     "isbot": "3.8.0",
     "merge-deep": "^3.0.3",
-    "@modern-js/plugin": "2.49.2",
-    "@modern-js/utils": "2.49.2",
-    "@modern-js/runtime-utils": "2.49.2"
+    "@modern-js/utils": "2.49.3",
+    "@modern-js/runtime-utils": "2.49.3",
+    "@modern-js/plugin": "2.49.3"
   },
   "devDependencies": {
     "@types/jest": "^29",
@@ -81,9 +81,9 @@
     "jest": "^29",
     "ts-jest": "^29.1.0",
     "typescript": "^5",
-    "@scripts/build": "2.49.2",
-    "@scripts/jest-config": "2.49.2",
-    "@modern-js/types": "2.49.2"
+    "@modern-js/types": "2.49.3",
+    "@scripts/jest-config": "2.49.3",
+    "@scripts/build": "2.49.3"
   },
   "sideEffects": false,
   "publishConfig": {