@modern-js/server-core 2.64.1 → 2.64.2

package/dist/esm-node/plugins/render/render.js

@@ -2,8 +2,10 @@ import { cutNameByHyphen } from "@modern-js/utils/universal";
 import { TrieRouter } from "hono/router/trie-router";
 import { X_MODERNJS_RENDER } from "../../constants";
 import { uniqueKeyByRoute } from "../../utils";
-import { ErrorDigest, createErrorHtml, getPathname, getRuntimeEnv, onError as onErrorFn, parseHeaders, parseQuery, sortRoutes } from "../../utils";
+import { ErrorDigest, createErrorHtml, getPathname, getRuntimeEnv, parseHeaders, parseQuery, sortRoutes } from "../../utils";
 import { dataHandler } from "./dataHandler";
+import { renderRscHandler } from "./renderRscHandler";
+import { serverActionHandler } from "./serverActionHandler";
 import { ssrRender } from "./ssrRender";
 const DYNAMIC_ROUTE_REG = /\/:./;
 function getRouter(routes) {
@@ -47,17 +49,17 @@ function getHeadersWithoutCookie(headers) {
   delete _headers.cookie;
   return _headers;
 }
-async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, config, onFallback: onFallbackFn }) {
+async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, config, onFallback }) {
   const router = getRouter(routes);
-  return async (req, { logger, reporter, metrics, monitors, nodeReq, templates, serverManifest, locals, matchEntryName, matchPathname, loaderContext }) => {
+  return async (req, { logger, reporter, metrics, monitors, nodeReq, templates, serverManifest, rscClientManifest, rscSSRManifest, rscServerManifest, locals, matchEntryName, matchPathname, loaderContext }) => {
     const forMatchpathname = matchPathname !== null && matchPathname !== void 0 ? matchPathname : getPathname(req);
     const [routeInfo, params] = matchRoute(router, forMatchpathname, matchEntryName);
     const framework = metaName || "modern-js";
     const fallbackHeader = `x-${cutNameByHyphen(framework)}-ssr-fallback`;
     let fallbackReason = null;
-    const onFallback = async (reason, error) => {
+    const fallbackWrapper = async (reason, error) => {
       fallbackReason = reason;
-      return onFallbackFn === null || onFallbackFn === void 0 ? void 0 : onFallbackFn(reason, {
+      return onFallback === null || onFallback === void 0 ? void 0 : onFallback(reason, {
         logger,
         reporter,
         metrics
@@ -80,18 +82,14 @@ async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig
         }
       });
     }
-    const renderMode = await getRenderMode(req, fallbackHeader, routeInfo.isSSR, forceCSR, nodeReq, onFallback);
+    const renderMode = await getRenderMode(req, fallbackHeader, routeInfo.isSSR, forceCSR, nodeReq, fallbackWrapper);
     const headerData = parseHeaders(req);
-    const onError = (e) => {
-      monitors === null || monitors === void 0 ? void 0 : monitors.error(`SSR Error - ${e instanceof Error ? e.name : e}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, forMatchpathname, getHeadersWithoutCookie(headerData));
+    const onError = (e, key) => {
+      monitors === null || monitors === void 0 ? void 0 : monitors.error(`SSR Error - ${key || (e instanceof Error ? e.name : e)}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, forMatchpathname, getHeadersWithoutCookie(headerData));
     };
     const onTiming = (name, dur) => {
       monitors === null || monitors === void 0 ? void 0 : monitors.timing(name, dur, "SSR");
     };
-    const onBoundError = async (e) => {
-      onErrorFn(ErrorDigest.ERENDER, e, monitors, req);
-      await (onFallback === null || onFallback === void 0 ? void 0 : onFallback("error", e));
-    };
     const renderOptions = {
       pwd,
       html,
@@ -106,6 +104,9 @@ async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig
       logger,
       metrics,
       locals,
+      rscClientManifest,
+      rscSSRManifest,
+      rscServerManifest,
       serverManifest,
       loaderContext: loaderContext || /* @__PURE__ */ new Map(),
       onError,
@@ -114,11 +115,17 @@ async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig
     let response;
     switch (renderMode) {
       case "data":
-        response = await dataHandler(req, renderOptions) || await renderHandler(req, renderOptions, "ssr", onBoundError);
+        response = await dataHandler(req, renderOptions) || await renderHandler(req, renderOptions, "ssr", fallbackWrapper);
+        break;
+      case "rsc-tree":
+        response = await renderRscHandler(req, renderOptions);
+        break;
+      case "rsc-action":
+        response = await serverActionHandler(req, renderOptions);
         break;
       case "ssr":
       case "csr":
-        response = await renderHandler(req, renderOptions, renderMode, onBoundError);
+        response = await renderHandler(req, renderOptions, renderMode, fallbackWrapper);
         break;
       default:
         throw new Error(`Unknown render mode: ${renderMode}`);
@@ -129,7 +136,7 @@ async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig
     return response;
   };
 }
-async function renderHandler(request, options, mode, onError) {
+async function renderHandler(request, options, mode, fallbackWrapper) {
   var _options_config_server;
   let response = null;
   const { serverManifest } = options;
@@ -159,7 +166,8 @@ async function renderHandler(request, options, mode, onError) {
     try {
       response = await ssrRender(request, options);
     } catch (e) {
-      await onError(e);
+      options.onError(e, ErrorDigest.ERENDER);
+      await fallbackWrapper("error", e);
       response = csrRender(options.html);
     }
   } else {
@@ -176,6 +184,12 @@ async function renderHandler(request, options, mode, onError) {
 }
 async function getRenderMode(req, fallbackHeader, isSSR, forceCSR, nodeReq, onFallback) {
   const query = parseQuery(req);
+  if (req.headers.get("x-rsc-action")) {
+    return "rsc-action";
+  }
+  if (req.headers.get("x-rsc-tree")) {
+    return "rsc-tree";
+  }
   if (isSSR) {
     if (query.__loader) {
       return "data";

package/dist/esm-node/plugins/render/renderRscHandler.js

@@ -0,0 +1,27 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+const renderRscHandler = async (req, { serverManifest, routeInfo, rscClientManifest }) => {
+  var _serverManifest_renderBundles;
+  const serverBundle = serverManifest === null || serverManifest === void 0 ? void 0 : (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[routeInfo.entryName || MAIN_ENTRY_NAME];
+  if (!serverBundle) {
+    return new Response("Cannot find server bundle for RSC", {
+      status: 500
+    });
+  }
+  const { rscRequestHandler } = serverBundle;
+  if (!rscRequestHandler) {
+    return new Response("Cannot find request handler for RSC", {
+      status: 500
+    });
+  }
+  if (!rscClientManifest) {
+    return new Response("Cannot find rsc client manifest", {
+      status: 500
+    });
+  }
+  return rscRequestHandler({
+    clientManifest: rscClientManifest
+  });
+};
+export {
+  renderRscHandler
+};

package/dist/esm-node/plugins/render/serverActionHandler.js

@@ -0,0 +1,27 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+const serverActionHandler = async (req, { serverManifest, routeInfo, rscClientManifest }) => {
+  var _serverManifest_renderBundles;
+  const serverBundle = serverManifest === null || serverManifest === void 0 ? void 0 : (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[routeInfo.entryName || MAIN_ENTRY_NAME];
+  if (!serverBundle) {
+    return new Response("Cannot find server bundle for server action", {
+      status: 500
+    });
+  }
+  const { handleAction } = serverBundle;
+  if (!handleAction) {
+    return new Response("Cannot find server action handler", {
+      status: 500
+    });
+  }
+  if (!rscClientManifest) {
+    return new Response("Cannot find rsc client manifest", {
+      status: 500
+    });
+  }
+  return handleAction(req, {
+    clientManifest: rscClientManifest
+  });
+};
+export {
+  serverActionHandler
+};

package/dist/esm-node/plugins/render/ssrRender.js

@@ -3,7 +3,7 @@ import { X_MODERNJS_RENDER } from "../../constants";
 import { getPathname, parseHeaders } from "../../utils";
 import { getCacheResult, matchCacheControl } from "./ssrCache";
 const SERVER_RUNTIME_ENTRY = "requestHandler";
-async function ssrRender(request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, locals, params, loaderContext, reporter, cacheConfig, logger, metrics, onError, onTiming }) {
+async function ssrRender(request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, reporter, cacheConfig, logger, metrics, onError, onTiming }) {
   var _serverManifest_renderBundles;
   const { entryName } = routeInfo;
   const loadableStats = serverManifest.loadableStats || {};
@@ -33,6 +33,9 @@ async function ssrRender(request, { routeInfo, html, config: userConfig, staticG
     params,
     loaderContext,
     config,
+    rscSSRManifest,
+    rscClientManifest,
+    rscServerManifest,
     locals,
     reporter,
     staticGenerate,

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

@@ -41,7 +41,7 @@ var ErrorDigest;
 (function(ErrorDigest2) {
   ErrorDigest2["ENOTF"] = "Page could not be found";
   ErrorDigest2["EINTER"] = "Internal server error";
-  ErrorDigest2["ERENDER"] = "SSR render failed";
+  ErrorDigest2["ERENDER"] = "SSR render fallback";
 })(ErrorDigest || (ErrorDigest = {}));
 function onError(digest, error, monitors, req) {
   const headerData = req && parseHeaders(req);

package/dist/types/adapters/node/index.d.ts

@@ -1,5 +1,5 @@
 export { httpCallBack2HonoMid, connectMid2HonoMid } from './hono';
 export type { ServerNodeContext, ServerNodeMiddleware } from './hono';
 export { createNodeServer, sendResponse, createWebRequest, writeReadableStreamToWritable, } from './node';
-export { serverStaticPlugin, injectResourcePlugin, getHtmlTemplates, getServerManifest, injectNodeSeverPlugin, } from './plugins';
+export { serverStaticPlugin, injectResourcePlugin, getHtmlTemplates, getServerManifest, injectNodeSeverPlugin, injectRscManifestPlugin, } from './plugins';
 export { loadServerPlugins, loadServerEnv, loadServerRuntimeConfig, loadServerCliConfig, loadCacheConfig, } from './helper';

package/dist/types/adapters/node/plugins/resource.d.ts

@@ -3,5 +3,9 @@ import type { Middleware, ServerEnv, ServerManifest, ServerPlugin } from '../../
 export declare function getHtmlTemplates(pwd: string, routes: ServerRoute[]): Promise<Record<string, string>>;
 export declare function injectTemplates(pwd: string, routes?: ServerRoute[], htmlTemplatePromise?: ReturnType<typeof getHtmlTemplates>): Middleware<ServerEnv>;
 export declare function getServerManifest(pwd: string, routes: ServerRoute[], logger: Logger): Promise<ServerManifest>;
-export declare function injectServerManifest(pwd: string, routes?: ServerRoute[]): Middleware<ServerEnv>;
+export declare function injectServerManifest(pwd: string, routes?: ServerRoute[], manifestPromise?: Promise<ServerManifest>): Middleware<ServerEnv>;
+export declare function getRscServerManifest(pwd: string): Promise<any>;
+export declare function getClientManifest(pwd: string): Promise<any>;
+export declare function getRscSSRManifest(pwd: string): Promise<any>;
+export declare const injectRscManifestPlugin: () => ServerPlugin;
 export declare const injectResourcePlugin: () => ServerPlugin;

package/dist/types/plugins/default.d.ts

@@ -2,6 +2,6 @@ import type { Logger } from '@modern-js/types';
 import type { ServerPlugin } from '../types';
 import { type InjectRenderHandlerOptions } from './render';
 export type CreateDefaultPluginsOptions = InjectRenderHandlerOptions & {
-    logger?: Logger;
+    logger?: Logger | false;
 };
 export declare function createDefaultPlugins(options?: CreateDefaultPluginsOptions): ServerPlugin[];

package/dist/types/plugins/render/render.d.ts

@@ -12,5 +12,5 @@ interface CreateRenderOptions {
     forceCSR?: boolean;
     nonce?: string;
 }
-export declare function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, config, onFallback: onFallbackFn, }: CreateRenderOptions): Promise<Render>;
+export declare function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, config, onFallback, }: CreateRenderOptions): Promise<Render>;
 export {};

package/dist/types/plugins/render/renderRscHandler.d.ts

@@ -0,0 +1,2 @@
+import type { SSRRenderOptions } from './ssrRender';
+export declare const renderRscHandler: (req: Request, { serverManifest, routeInfo, rscClientManifest }: SSRRenderOptions) => Promise<Response>;

package/dist/types/plugins/render/serverActionHandler.d.ts

@@ -0,0 +1,2 @@
+import type { SSRRenderOptions } from './ssrRender';
+export declare const serverActionHandler: (req: Request, { serverManifest, routeInfo, rscClientManifest }: SSRRenderOptions) => Promise<Response>;

package/dist/types/plugins/render/ssrRender.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import type { IncomingMessage } from 'http';
 import type { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
+import type { ClientManifest as RscClientManifest, SSRManifest as RscSSRManifest, ServerManifest as RscServerManifest } from '@modern-js/types/server';
 import type { CacheConfig, ServerManifest, UserConfig } from '../../types';
 import type { OnError, OnTiming, Params } from '../../types/requestHandler';
 export interface SSRRenderOptions {
@@ -10,6 +11,9 @@ export interface SSRRenderOptions {
     staticGenerate: boolean;
     config: UserConfig;
     serverManifest: ServerManifest;
+    rscServerManifest?: RscServerManifest;
+    rscClientManifest?: RscClientManifest;
+    rscSSRManifest?: RscSSRManifest;
     loaderContext: Map<string, unknown>;
     params: Params;
     logger: Logger;
@@ -19,7 +23,7 @@ export interface SSRRenderOptions {
     locals?: Record<string, any>;
     cacheConfig?: CacheConfig;
     nodeReq?: IncomingMessage;
-    onError?: OnError;
-    onTiming?: OnTiming;
+    onError: OnError;
+    onTiming: OnTiming;
 }
-export declare function ssrRender(request: Request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, locals, params, loaderContext, reporter, cacheConfig, logger, metrics, onError, onTiming, }: SSRRenderOptions): Promise<Response>;
+export declare function ssrRender(request: Request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, reporter, cacheConfig, logger, metrics, onError, onTiming, }: SSRRenderOptions): Promise<Response>;

package/dist/types/types/config/server.d.ts

@@ -25,6 +25,7 @@ export interface ServerUserConfig {
     publicRoutes?: Record<string, string>;
     ssr?: SSR;
     ssrByEntries?: SSRByEntries;
+    rsc?: boolean;
     baseUrl?: string | string[];
     port?: number;
     watchOptions?: WatchOptions;
@@ -34,6 +35,7 @@ export interface ServerUserConfig {
      * @default false
      */
     useJsonScript?: boolean;
+    logger?: boolean | Record<string, unknown>;
 }
 export type ServerNormalizedConfig = ServerUserConfig;
 export {};

package/dist/types/types/render.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { IncomingMessage } from 'node:http';
-import type { Logger, Metrics, Monitors, Reporter } from '@modern-js/types';
+import type { Logger, Metrics, Monitors, Reporter, ClientManifest as RscClientManifest, SSRManifest as RscSSRManifest, ServerManifest as RscServerManifest } from '@modern-js/types';
 import type { ServerManifest } from './server';
 export interface RenderOptions {
     loaderContext?: Map<string, unknown>;
@@ -20,6 +20,9 @@ export interface RenderOptions {
     matchEntryName?: string;
     monitors?: Monitors;
     serverManifest: ServerManifest;
+    rscServerManifest?: RscServerManifest;
+    rscClientManifest?: RscClientManifest;
+    rscSSRManifest?: RscSSRManifest;
     nodeReq?: IncomingMessage;
 }
 export type Render = (request: Request, options: RenderOptions) => Promise<Response>;

package/dist/types/types/requestHandler.d.ts

@@ -1,4 +1,5 @@
 import type { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
+import type { ClientManifest as RscClientManifest, SSRManifest as RscSSRManifest, ServerManifest as RscServerManifest } from '@modern-js/types/server';
 import type { ServerUserConfig, SourceUserConfig } from './config';
 export type Resource = {
     loadableStats: Record<string, any>;
@@ -20,13 +21,18 @@ export type RequestHandlerConfig = {
     enableAsyncEntry?: SourceUserConfig['enableAsyncEntry'];
 };
 export type LoaderContext = Map<string, any>;
-export type OnError = (err: unknown) => void;
+export type OnError = (err: unknown, key?: string) => void;
 export type OnTiming = (name: string, dur: number) => void;
 export type RequestHandlerOptions = {
     resource: Resource;
     config: RequestHandlerConfig;
     params: Params;
     loaderContext: LoaderContext;
+    rscServerManifest?: RscServerManifest;
+    rscClientManifest?: RscClientManifest;
+    rscSSRManifest?: RscSSRManifest;
+    RSCRoot?: any;
+    rscRoot?: any;
     /** @deprecated  */
     locals?: Record<string, any>;
     /** @deprecated  */
@@ -37,7 +43,7 @@ export type RequestHandlerOptions = {
     logger: Logger;
     /** @deprecated */
     metrics?: Metrics;
-    onError?: OnError;
-    onTiming?: OnTiming;
+    onError: OnError;
+    onTiming: OnTiming;
 };
 export type RequestHandler = (request: Request, options: RequestHandlerOptions) => Promise<Response>;

package/dist/types/types/server.d.ts

@@ -1,4 +1,5 @@
 import type { Logger, Metrics, Monitors, NestedRoute, Reporter, ServerRoute } from '@modern-js/types';
+import type { ClientManifest as RscClientManifest, SSRManifest as RscSSRManifest, ServerManifest as RscServerManifest } from '@modern-js/types/server';
 import type { RequestHandler as BundleRequestHandler, OnError, OnTiming } from './requestHandler';
 export type RequestHandler = (request: Request, ...args: any[]) => Response | Promise<Response>;
 type ServerLoaderBundle = {
@@ -16,7 +17,13 @@ type ServerLoaderBundle = {
     }) => Promise<any>;
 };
 type ServerRenderBundle = {
-    requestHandler: Promise<BundleRequestHandler>;
+    requestHandler?: Promise<BundleRequestHandler>;
+    handleAction?: (req: Request, options: {
+        clientManifest: RscClientManifest;
+    }) => Promise<Response>;
+    rscRequestHandler?: (options: {
+        clientManifest: RscClientManifest;
+    }) => Promise<Response>;
 };
 export type ServerManifest = {
     loaderBundles?: Record<string, ServerLoaderBundle>;
@@ -34,6 +41,9 @@ type ServerVariables = {
     metrics?: Metrics;
     monitors: Monitors;
     serverManifest?: ServerManifest;
+    rscServerManifest?: RscServerManifest;
+    rscClientManifest?: RscClientManifest;
+    rscSSRManifest?: RscSSRManifest;
     templates?: Record<string, string>;
     matchPathname?: string;
     matchEntryName?: string;

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

@@ -3,6 +3,6 @@ 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"
+    ERENDER = "SSR render fallback"
 }
 export declare function onError(digest: ErrorDigest, error: Error | string, monitors?: Monitors, req?: Request): void;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.64.1",
+  "version": "2.64.2",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -53,9 +53,9 @@
     "flatted": "^3.2.9",
     "hono": "^3.12.2",
     "ts-deepmerge": "7.0.2",
-    "@modern-js/plugin": "2.64.1",
-    "@modern-js/runtime-utils": "2.64.1",
-    "@modern-js/utils": "2.64.1"
+    "@modern-js/plugin": "2.64.2",
+    "@modern-js/runtime-utils": "2.64.2",
+    "@modern-js/utils": "2.64.2"
   },
   "devDependencies": {
     "@types/jest": "^29",
@@ -65,9 +65,9 @@
     "jest": "^29",
     "ts-jest": "^29.1.0",
     "typescript": "^5",
-    "@modern-js/types": "2.64.1",
-    "@scripts/build": "2.64.1",
-    "@scripts/jest-config": "2.64.1"
+    "@modern-js/types": "2.64.2",
+    "@scripts/build": "2.64.2",
+    "@scripts/jest-config": "2.64.2"
   },
   "sideEffects": false,
   "publishConfig": {