@modern-js/server-core 2.54.5 → 2.55.0

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

@@ -1,42 +1,24 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
-import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { SERVER_RENDER_FUNCTION_NAME, MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-import * as isbot from "isbot";
-import { getRuntimeEnv, parseHeaders, parseQuery, getHost, getPathname } from "../../utils";
-import { X_MODERNJS_RENDER, X_RENDER_CACHE } from "../../constants";
-import { ServerTiming } from "./serverTiming";
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import { parseHeaders, getPathname } from "../../utils";
+import { X_MODERNJS_RENDER } from "../../constants";
 import { matchCacheControl, getCacheResult } from "./ssrCache";
-var defaultReporter = {
-  init: function init() {
-  },
-  reportError: function reportError() {
-  },
-  reportTiming: function reportTiming() {
-  },
-  reportInfo: function reportInfo() {
-  },
-  reportWarn: function reportWarn() {
-  }
-};
+var SERVER_RUNTIME_ENTRY = "requestHandler";
 function ssrRender(request, _) {
   return _ssrRender.apply(this, arguments);
 }
 function _ssrRender() {
   _ssrRender = _async_to_generator(function(request, param) {
-    var routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, cacheConfig, _serverManifest_renderBundles, entryName, loadableStats, routeManifest, host, isSpider, responseProxy, query, headers, key, ssrContext, renderBundle, runtimeEnv, ssrResult, cacheStatus, render, cacheControl, _ref, data, status, redirection, headers1, Readable, streamModule, createReadableStreamFromReadable, _tmp, data1;
+    var routeInfo, html, userConfig, staticGenerate, nodeReq, serverManifest, locals, params, loaderContext, reporter, cacheConfig, logger, metrics, onError, onTiming, _serverManifest_renderBundles, entryName, loadableStats, routeManifest, headers, key, renderBundle, requestHandler, config, requestHandlerOptions, cacheControl, response;
     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, params = param.params, metrics = param.metrics, loaderContext = param.loaderContext, cacheConfig = param.cacheConfig;
+          routeInfo = param.routeInfo, html = param.html, userConfig = param.config, staticGenerate = param.staticGenerate, nodeReq = param.nodeReq, serverManifest = param.serverManifest, locals = param.locals, params = param.params, loaderContext = param.loaderContext, reporter = param.reporter, cacheConfig = param.cacheConfig, logger = param.logger, metrics = param.metrics, onError = param.onError, onTiming = param.onTiming;
           entryName = routeInfo.entryName;
           loadableStats = serverManifest.loadableStats || {};
           routeManifest = serverManifest.routeManifest || {};
-          host = getHost(request);
-          isSpider = isbot.default(request.headers.get("user-agent"));
-          responseProxy = new ResponseProxy();
-          query = parseQuery(request);
           headers = parseHeaders(request);
           if (nodeReq) {
             for (var key2 in nodeReq.headers) {
@@ -45,164 +27,82 @@ function _ssrRender() {
               }
             }
           }
-          ssrContext = {
-            request: {
-              baseUrl: routeInfo.urlPath,
-              params,
-              pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : getPathname(request),
-              host,
-              query,
-              url: nodeReq ? getHrefFromNodeReq(nodeReq) : request.url,
-              headers
-            },
-            response: {
-              setHeader: function setHeader(key3, value) {
-                responseProxy.headers.set(key3, value);
-              },
-              status: function status2(code) {
-                responseProxy.status = code;
-              },
-              locals: locals || {}
+          renderBundle = (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[entryName || MAIN_ENTRY_NAME];
+          if (!renderBundle) {
+            throw new Error("Can't found renderBundle ".concat(entryName || MAIN_ENTRY_NAME));
+          }
+          return [
+            4,
+            renderBundle[SERVER_RUNTIME_ENTRY]
+          ];
+        case 1:
+          requestHandler = _state.sent();
+          config = createRequestHandlerConfig(userConfig);
+          requestHandlerOptions = {
+            resource: {
+              route: routeInfo,
+              loadableStats,
+              routeManifest,
+              htmlTemplate: html,
+              entryName: entryName || MAIN_ENTRY_NAME
             },
-            redirection: {},
-            template: html,
-            loadableStats,
+            params,
             loaderContext,
-            routeManifest,
-            entryName,
+            config,
+            locals,
+            reporter,
             staticGenerate,
             logger,
             metrics,
-            serverTiming: new ServerTiming(responseProxy.headers, metaName),
-            reporter: reporter || defaultReporter,
-            /** @deprecated node req */
-            req: nodeReq || request,
-            /** @deprecated node res  */
-            res: void 0,
-            isSpider,
-            nonce
+            onError,
+            onTiming
           };
-          renderBundle = (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[entryName || MAIN_ENTRY_NAME];
-          if (!renderBundle) {
-            throw new Error("Can't found renderBundle ".concat(entryName || MAIN_ENTRY_NAME));
-          }
-          runtimeEnv = getRuntimeEnv();
-          render = renderBundle[SERVER_RENDER_FUNCTION_NAME];
           return [
             4,
             matchCacheControl(cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.strategy, nodeReq || new IncomingMessgeProxy(request))
           ];
-        case 1:
+        case 2:
           cacheControl = _state.sent();
           if (!cacheControl)
             return [
               3,
-              3
+              4
             ];
           return [
             4,
             getCacheResult(request, {
               cacheControl,
               container: cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.container,
-              render,
-              ssrContext
+              requestHandler,
+              requestHandlerOptions
             })
           ];
-        case 2:
-          _ref = _state.sent(), data = _ref.data, status = _ref.status;
-          ssrResult = data;
-          cacheStatus = status;
-          return [
-            3,
-            5
-          ];
         case 3:
+          response = _state.sent();
           return [
-            4,
-            render(ssrContext)
+            3,
+            6
           ];
         case 4:
-          ssrResult = _state.sent();
-          _state.label = 5;
-        case 5:
-          redirection = ssrContext.redirection;
-          if (cacheStatus) {
-            responseProxy.headers.set(X_RENDER_CACHE, cacheStatus);
-          }
-          responseProxy.headers.set(X_MODERNJS_RENDER, "server");
-          if (redirection.url) {
-            headers1 = responseProxy.headers;
-            headers1.set("Location", redirection.url);
-            return [
-              2,
-              new Response(null, {
-                status: redirection.status || 302,
-                headers: {
-                  Location: redirection.url
-                }
-              })
-            ];
-          }
           return [
             4,
-            import("stream").catch(function(_) {
-              return {
-                Readable: void 0
-              };
-            })
+            requestHandler(request, requestHandlerOptions)
           ];
+        case 5:
+          response = _state.sent();
+          _state.label = 6;
         case 6:
-          Readable = _state.sent().Readable;
-          streamModule = "../../adapters/node/polyfills/stream";
-          if (!(runtimeEnv === "node"))
-            return [
-              3,
-              8
-            ];
-          return [
-            4,
-            import(streamModule).catch(function(_) {
-              return {
-                createReadableStreamFromReadable: void 0
-              };
-            })
-          ];
-        case 7:
-          _tmp = _state.sent();
-          return [
-            3,
-            9
-          ];
-        case 8:
-          _tmp = {
-            createReadableStreamFromReadable: void 0
-          };
-          _state.label = 9;
-        case 9:
-          createReadableStreamFromReadable = _tmp.createReadableStreamFromReadable;
-          data1 = Readable && _instanceof(ssrResult, Readable) ? (createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(ssrResult)) || "" : ssrResult;
-          if (typeof data1 !== "string") {
-            responseProxy.headers.set("transfer-encoding", "chunked");
-          }
+          response.headers.set(X_MODERNJS_RENDER, "server");
+          response.headers.set("content-type", "text/html; charset=UTF-8");
           return [
             2,
-            new Response(data1, {
-              status: responseProxy.status,
-              headers: responseProxy.headers
-            })
+            response
           ];
       }
     });
   });
   return _ssrRender.apply(this, arguments);
 }
-var ResponseProxy = function ResponseProxy2() {
-  "use strict";
-  _class_call_check(this, ResponseProxy2);
-  this.headers = new Headers();
-  this.status = 200;
-  this.headers.set("content-type", "text/html; charset=UTF-8");
-};
 var IncomingMessgeProxy = function IncomingMessgeProxy2(req) {
   "use strict";
   var _this = this;
@@ -214,38 +114,18 @@ var IncomingMessgeProxy = function IncomingMessgeProxy2(req) {
   this.method = req.method;
   this.url = getPathname(req);
 };
-function getHrefFromNodeReq(nodeReq) {
-  function getProtocal() {
-    if (nodeReq.socket.encrypted) {
-      return "https";
-    }
-    var proto = nodeReq.headers["x-forwarded-proto"];
-    return proto ? proto.split(/\s*,\s*/, 1)[0] : "http";
-  }
-  function getHost2() {
-    var host = nodeReq.headers["x-forwarded-host"];
-    if (!host) {
-      host = nodeReq.headers.host;
-    }
-    host = host.split(/\s*,\s*/, 1)[0] || "undefined";
-    return host;
-  }
-  var href = "".concat(getProtocal(), "://").concat(getHost2()).concat(nodeReq.url || "");
-  return href;
-}
-function getPathnameFromNodeReq(nodeReq) {
-  var url = nodeReq.url;
-  if (!url) {
-    return "/";
-  }
-  var match = url.match(/\/[^?]*/);
-  var pathname = match ? match[0] : "/";
-  if (pathname !== "/" && pathname.endsWith("/")) {
-    pathname = pathname.slice(0, -1);
-  }
-  return pathname;
+function createRequestHandlerConfig(userConfig) {
+  var output = userConfig.output, server = userConfig.server, security = userConfig.security, html = userConfig.html;
+  return {
+    ssr: server === null || server === void 0 ? void 0 : server.ssr,
+    ssrByEntries: server === null || server === void 0 ? void 0 : server.ssrByEntries,
+    nonce: security === null || security === void 0 ? void 0 : security.nonce,
+    enableInlineScripts: output === null || output === void 0 ? void 0 : output.enableInlineScripts,
+    enableInlineStyles: output === null || output === void 0 ? void 0 : output.enableInlineStyles,
+    crossorigin: html === null || html === void 0 ? void 0 : html.crossorigin,
+    scriptLoading: html === null || html === void 0 ? void 0 : html.scriptLoading
+  };
 }
 export {
-  getPathnameFromNodeReq,
   ssrRender
 };

package/dist/esm/utils/transformStream.js

@@ -6,17 +6,31 @@ function createTransformStream(fn) {
   return new TransformStream({
     transform: function transform(chunk, controller) {
       return _async_to_generator(function() {
-        var content, newContent;
+        var content, newContent, _tmp;
         return _ts_generator(this, function(_state) {
           switch (_state.label) {
             case 0:
               content = decoder.decode(chunk);
+              if (!fn)
+                return [
+                  3,
+                  2
+                ];
               return [
                 4,
                 fn(content)
               ];
             case 1:
-              newContent = _state.sent();
+              _tmp = _state.sent();
+              return [
+                3,
+                3
+              ];
+            case 2:
+              _tmp = content;
+              _state.label = 3;
+            case 3:
+              newContent = _tmp;
               controller.enqueue(encoder.encode(newContent));
               return [
                 2

package/dist/esm-node/index.js

@@ -7,6 +7,7 @@ export * from "./types/plugin";
 export * from "./types/render";
 export * from "@modern-js/plugin";
 export * from "./types/config";
+export * from "./types/requestHandler";
 export {
   AGGRED_DIR,
   ErrorDigest,

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

@@ -1,5 +1,5 @@
 import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-const dataHandler = async (request, { routeInfo, serverRoutes, reporter, logger, serverManifest }) => {
+const dataHandler = async (request, { routeInfo, serverRoutes, reporter, onError, onTiming, serverManifest }) => {
   var _serverManifest_loaderBundles;
   const serverLoaderModule = serverManifest === null || serverManifest === void 0 ? void 0 : (_serverManifest_loaderBundles = serverManifest.loaderBundles) === null || _serverManifest_loaderBundles === void 0 ? void 0 : _serverManifest_loaderBundles[routeInfo.entryName || MAIN_ENTRY_NAME];
   if (!serverLoaderModule) {
@@ -10,9 +10,10 @@ const dataHandler = async (request, { routeInfo, serverRoutes, reporter, logger,
     request,
     serverRoutes,
     context: {
-      logger,
       reporter
     },
+    onTiming,
+    onError,
     routes
   });
   return response;

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

@@ -96,7 +96,7 @@ async function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, st
   const render = createRender({
     routes,
     pwd,
-    // TODO: need static Genrate
+    config,
     staticGenerate,
     cacheConfig,
     forceCSR,

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

@@ -1,9 +1,10 @@
 import { cutNameByHyphen } from "@modern-js/utils/universal";
 import { TrieRouter } from "hono/router/trie-router";
-import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse, onError as onErrorFn, ErrorDigest } from "../../utils";
+import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse, onError as onErrorFn, ErrorDigest, parseHeaders } from "../../utils";
 import { REPLACE_REG, X_MODERNJS_RENDER } from "../../constants";
 import { dataHandler } from "./dataHandler";
 import { ssrRender } from "./ssrRender";
+import { ServerTiming } from "./serverTiming";
 const DYNAMIC_ROUTE_REG = /\/:./;
 function getRouter(routes) {
   const dynamicRoutes = [];
@@ -33,7 +34,16 @@ function matchRoute(router, request) {
   const result = matched[0][0];
   return result || [];
 }
-async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, nonce, onFallback: onFallbackFn }) {
+function getHeadersWithoutCookie(headers) {
+  const _headers = {
+    ...headers,
+    cookie: void 0
+  };
+  delete _headers.cookie;
+  return _headers;
+}
+const SERVER_TIMING = "Server-Timing";
+async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, config, onFallback: onFallbackFn }) {
   const router = getRouter(routes);
   return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals, metrics, loaderContext }) => {
     const [routeInfo, params] = matchRoute(router, req);
@@ -62,7 +72,17 @@ async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig
       });
     }
     const renderMode = await getRenderMode(req, metaName || "modern-js", routeInfo.isSSR, forceCSR, nodeReq, onFallback);
-    const onError = async (e) => {
+    const pathname = getPathname(req);
+    const headerData = parseHeaders(req);
+    const serverTimingInstance = new ServerTiming(metaName || "modern");
+    const onError = (e) => {
+      logger.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, pathname, getHeadersWithoutCookie(headerData));
+    };
+    const onTiming = (name, dur) => {
+      logger.debug(`SSR Debug - ${name}, cost = %s, req.url = %s`, dur, pathname);
+      serverTimingInstance.addServeTiming(name, dur);
+    };
+    const onBoundError = async (e) => {
       onErrorFn(ErrorDigest.ERENDER, e, logger, req);
       await (onFallback === null || onFallback === void 0 ? void 0 : onFallback("error", e));
     };
@@ -71,32 +91,36 @@ async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig
       html,
       routeInfo,
       staticGenerate: staticGenerate || false,
-      metaName: metaName || "modern-js",
-      nonce,
-      logger,
+      config,
       nodeReq,
       cacheConfig,
       reporter,
       serverRoutes: routes,
       params,
+      logger,
+      metrics,
       locals,
       serverManifest,
-      metrics,
-      loaderContext: loaderContext || /* @__PURE__ */ new Map()
+      loaderContext: loaderContext || /* @__PURE__ */ new Map(),
+      onError,
+      onTiming
     };
+    let response;
     switch (renderMode) {
       case "data":
-        let response = await dataHandler(req, renderOptions);
-        if (!response) {
-          response = await renderHandler(req, renderOptions, "ssr", onError);
-        }
-        return response;
+        response = await dataHandler(req, renderOptions) || await renderHandler(req, renderOptions, "ssr", onBoundError);
+        break;
       case "ssr":
       case "csr":
-        return renderHandler(req, renderOptions, renderMode, onError);
+        response = await renderHandler(req, renderOptions, renderMode, onBoundError);
+        break;
       default:
         throw new Error(`Unknown render mode: ${renderMode}`);
     }
+    serverTimingInstance.headers.forEach((value) => {
+      response.headers.append(SERVER_TIMING, value);
+    });
+    return response;
   };
 }
 async function renderHandler(request, options, mode, onError) {

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

@@ -1,14 +1,16 @@
-const SERVER_TIMING = "Server-Timing";
 class ServerTiming {
+  get headers() {
+    return this.headerList;
+  }
   addServeTiming(name, dur, desc) {
     const _name = `bd-${this.meta}-${name}`;
     const value = `${_name};${desc ? `decs="${desc}";` : ""} dur=${dur}`;
-    this.headers.append(SERVER_TIMING, value);
+    this.headerList.push(value);
     return this;
   }
-  constructor(headers, meta) {
+  constructor(meta) {
+    this.headerList = [];
     this.meta = meta;
-    this.headers = headers;
   }
 }
 export {

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

@@ -1,70 +1,40 @@
 import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
-import { createTransformStream, getPathname, getRuntimeEnv } from "../../utils";
-async function processCache(key, render, ssrContext, ttl, container, status) {
-  const renderResult = await render(ssrContext);
-  if (!renderResult) {
-    return {
-      data: ""
-    };
-  } else if (typeof renderResult === "string") {
-    const current = Date.now();
-    const cache = {
-      val: renderResult,
-      cursor: current
-    };
-    await container.set(key, JSON.stringify(cache), {
-      ttl
-    });
-    return {
-      data: renderResult,
-      status
-    };
-  } else {
-    const { Readable } = await import("stream").catch((_) => ({
-      Readable: void 0
-    }));
-    const runtimeEnv = getRuntimeEnv();
-    const streamModule = "../../adapters/node/polyfills/stream";
-    const { createReadableStreamFromReadable } = runtimeEnv === "node" ? await import(streamModule).catch((_) => ({
-      createReadableStreamFromReadable: void 0
-    })) : {
-      createReadableStreamFromReadable: void 0
-    };
-    const body = (
-      // TODO: remove node:stream, move it to ssr entry.
-      Readable && renderResult instanceof Readable ? createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(renderResult) : renderResult
-    );
+import { X_RENDER_CACHE } from "../../constants";
+import { createTransformStream, getPathname } from "../../utils";
+async function processCache({ request, key, requestHandler, requestHandlerOptions, ttl, container, cacheStatus }) {
+  const response = await requestHandler(request, requestHandlerOptions);
+  const decoder = new TextDecoder();
+  if (response.body) {
+    const stream = createTransformStream();
+    const reader = response.body.getReader();
+    const writer = stream.writable.getWriter();
     let html = "";
-    const stream = createTransformStream((chunk) => {
-      html += chunk;
-      return chunk;
+    const push = () => reader.read().then(({ done, value }) => {
+      if (done) {
+        const current = Date.now();
+        const cache = {
+          val: html,
+          cursor: current
+        };
+        container.set(key, JSON.stringify(cache), {
+          ttl
+        });
+        writer.close();
+        return;
+      }
+      const content = decoder.decode(value);
+      html += content;
+      writer.write(value);
+      push();
     });
-    const reader = body.getReader();
-    const writer = stream.writable.getWriter();
-    const push = () => {
-      reader.read().then(({ done, value }) => {
-        if (done) {
-          const current = Date.now();
-          const cache = {
-            val: html,
-            cursor: current
-          };
-          container.set(key, JSON.stringify(cache), {
-            ttl
-          });
-          writer.close();
-          return;
-        }
-        writer.write(value);
-        push();
-      });
-    };
     push();
-    return {
-      data: stream.readable,
-      status
-    };
+    cacheStatus && response.headers.set(X_RENDER_CACHE, cacheStatus);
+    return new Response(stream.readable, {
+      status: response.status,
+      headers: response.headers
+    });
   }
+  return response;
 }
 const CACHE_NAMESPACE = "__ssr__cache";
 const storage = createMemoryStorage(CACHE_NAMESPACE);
@@ -111,7 +81,7 @@ function matchCacheControl(cacheOption, req) {
   }
 }
 async function getCacheResult(request, options) {
-  const { cacheControl, render, ssrContext, container = storage } = options;
+  const { cacheControl, container = storage, requestHandler, requestHandlerOptions } = options;
   const key = computedKey(request, cacheControl);
   const value = await container.get(key);
   const { maxAge, staleWhileRevalidate } = cacheControl;
@@ -120,21 +90,50 @@ async function getCacheResult(request, options) {
     const cache = JSON.parse(value);
     const interval = Date.now() - cache.cursor;
     if (interval <= maxAge) {
-      return {
-        data: cache.val,
-        status: "hit"
-      };
+      const cacheStatus = "hit";
+      return new Response(cache.val, {
+        headers: {
+          [X_RENDER_CACHE]: cacheStatus
+        }
+      });
     } else if (interval <= staleWhileRevalidate + maxAge) {
-      processCache(key, render, ssrContext, ttl, container);
-      return {
-        data: cache.val,
-        status: "stale"
-      };
+      processCache({
+        key,
+        request,
+        requestHandler,
+        requestHandlerOptions,
+        ttl,
+        container
+      }).then(async (response) => {
+        await response.text();
+      });
+      const cacheStatus = "stale";
+      return new Response(cache.val, {
+        headers: {
+          [X_RENDER_CACHE]: cacheStatus
+        }
+      });
     } else {
-      return processCache(key, render, ssrContext, ttl, container, "expired");
+      return processCache({
+        key,
+        request,
+        requestHandler,
+        requestHandlerOptions,
+        ttl,
+        container,
+        cacheStatus: "expired"
+      });
     }
   } else {
-    return processCache(key, render, ssrContext, ttl, container, "miss");
+    return processCache({
+      key,
+      request,
+      requestHandler,
+      requestHandlerOptions,
+      ttl,
+      container,
+      cacheStatus: "miss"
+    });
   }
 }
 export {