@modern-js/server-core 2.54.6 → 2.55.0

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

@@ -208,7 +208,7 @@ function _getRenderHandler() {
       render = createRender({
         routes,
         pwd,
-        // TODO: need static Genrate
+        config,
         staticGenerate,
         cacheConfig,
         forceCSR,

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

@@ -1,14 +1,18 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { cutNameByHyphen } from "@modern-js/utils/universal";
 import { TrieRouter } from "hono/router/trie-router";
-import { 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";
 var DYNAMIC_ROUTE_REG = /\/:./;
 function getRouter(routes) {
   var dynamicRoutes = [];
@@ -52,20 +56,28 @@ function matchRoute(router, request) {
   var result = matched[0][0];
   return result || [];
 }
+function getHeadersWithoutCookie(headers) {
+  var _headers = _object_spread_props(_object_spread({}, headers), {
+    cookie: void 0
+  });
+  delete _headers.cookie;
+  return _headers;
+}
+var SERVER_TIMING = "Server-Timing";
 function createRender(_) {
   return _createRender.apply(this, arguments);
 }
 function _createRender() {
   _createRender = _async_to_generator(function(param) {
-    var routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, nonce, onFallbackFn, router;
+    var routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, config, onFallbackFn, router;
     return _ts_generator(this, function(_state) {
-      routes = param.routes, pwd = param.pwd, metaName = param.metaName, staticGenerate = param.staticGenerate, cacheConfig = param.cacheConfig, forceCSR = param.forceCSR, nonce = param.nonce, onFallbackFn = param.onFallback;
+      routes = param.routes, pwd = param.pwd, metaName = param.metaName, staticGenerate = param.staticGenerate, cacheConfig = param.cacheConfig, forceCSR = param.forceCSR, config = param.config, onFallbackFn = param.onFallback;
       router = getRouter(routes);
       return [
         2,
         function() {
           var _ref = _async_to_generator(function(req, param2) {
-            var logger, nodeReq, reporter, templates, serverManifest, locals, metrics, loaderContext, _matchRoute, routeInfo, params, onFallback, html, renderMode, onError, renderOptions, response;
+            var logger, nodeReq, reporter, templates, serverManifest, locals, metrics, loaderContext, _matchRoute, routeInfo, params, onFallback, html, renderMode, pathname, headerData, serverTimingInstance, onError, onTiming, onBoundError, renderOptions, response, _tmp;
             return _ts_generator(this, function(_state2) {
               switch (_state2.label) {
                 case 0:
@@ -117,7 +129,17 @@ function _createRender() {
                   ];
                 case 1:
                   renderMode = _state2.sent();
-                  onError = function() {
+                  pathname = getPathname(req);
+                  headerData = parseHeaders(req);
+                  serverTimingInstance = new ServerTiming(metaName || "modern");
+                  onError = function(e) {
+                    logger.error("SSR Error - ".concat(_instanceof(e, Error) ? e.name : e, ", error = %s, req.url = %s, req.headers = %o"), _instanceof(e, Error) ? e.stack || e.message : e, pathname, getHeadersWithoutCookie(headerData));
+                  };
+                  onTiming = function(name, dur) {
+                    logger.debug("SSR Debug - ".concat(name, ", cost = %s, req.url = %s"), dur, pathname);
+                    serverTimingInstance.addServeTiming(name, dur);
+                  };
+                  onBoundError = function() {
                     var _ref2 = _async_to_generator(function(e) {
                       return _ts_generator(this, function(_state3) {
                         switch (_state3.label) {
@@ -135,7 +157,7 @@ function _createRender() {
                         }
                       });
                     });
-                    return function onError2(e) {
+                    return function onBoundError2(e) {
                       return _ref2.apply(this, arguments);
                     };
                   }();
@@ -144,18 +166,19 @@ function _createRender() {
                     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
                   };
                   switch (renderMode) {
                     case "data":
@@ -176,7 +199,7 @@ function _createRender() {
                   }
                   return [
                     3,
-                    7
+                    8
                   ];
                 case 2:
                   return [
@@ -184,34 +207,45 @@ function _createRender() {
                     dataHandler(req, renderOptions)
                   ];
                 case 3:
-                  response = _state2.sent();
-                  if (!!response)
+                  _tmp = _state2.sent();
+                  if (_tmp)
                     return [
                       3,
                       5
                     ];
                   return [
                     4,
-                    renderHandler(req, renderOptions, "ssr", onError)
+                    renderHandler(req, renderOptions, "ssr", onBoundError)
                   ];
                 case 4:
-                  response = _state2.sent();
+                  _tmp = _state2.sent();
                   _state2.label = 5;
                 case 5:
+                  response = _tmp;
                   return [
-                    2,
-                    response
+                    3,
+                    9
                   ];
                 case 6:
                   return [
-                    2,
-                    renderHandler(req, renderOptions, renderMode, onError)
+                    4,
+                    renderHandler(req, renderOptions, renderMode, onBoundError)
                   ];
                 case 7:
-                  throw new Error("Unknown render mode: ".concat(renderMode));
+                  response = _state2.sent();
+                  return [
+                    3,
+                    9
+                  ];
                 case 8:
+                  throw new Error("Unknown render mode: ".concat(renderMode));
+                case 9:
+                  serverTimingInstance.headers.forEach(function(value) {
+                    response.headers.append(SERVER_TIMING, value);
+                  });
                   return [
-                    2
+                    2,
+                    response
                   ];
               }
             });

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

@@ -1,19 +1,27 @@
 import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
-var SERVER_TIMING = "Server-Timing";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
 var ServerTiming = /* @__PURE__ */ function() {
   "use strict";
-  function ServerTiming2(headers, meta) {
+  function ServerTiming2(meta) {
     _class_call_check(this, ServerTiming2);
+    this.headerList = [];
     this.meta = meta;
-    this.headers = headers;
   }
   var _proto = ServerTiming2.prototype;
   _proto.addServeTiming = function addServeTiming(name, dur, desc) {
     var _name = "bd-".concat(this.meta, "-").concat(name);
     var value = "".concat(_name, ";").concat(desc ? 'decs="'.concat(desc, '";') : "", " dur=").concat(dur);
-    this.headers.append(SERVER_TIMING, value);
+    this.headerList.push(value);
     return this;
   };
+  _create_class(ServerTiming2, [
+    {
+      key: "headers",
+      get: function get() {
+        return this.headerList;
+      }
+    }
+  ]);
   return ServerTiming2;
 }();
 export {

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

@@ -1,139 +1,66 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
-import { createTransformStream, getPathname, getRuntimeEnv } from "../../utils";
-function processCache(key, render, ssrContext, ttl, container, status) {
+import { X_RENDER_CACHE } from "../../constants";
+import { createTransformStream, getPathname } from "../../utils";
+function processCache(_) {
   return _processCache.apply(this, arguments);
 }
 function _processCache() {
-  _processCache = _async_to_generator(function(key, render, ssrContext, ttl, container, status) {
-    var renderResult, current, cache, Readable, runtimeEnv, streamModule, createReadableStreamFromReadable, _tmp, body, html, stream, reader, writer, push;
+  _processCache = _async_to_generator(function(param) {
+    var request, key, requestHandler, requestHandlerOptions, ttl, container, cacheStatus, response, decoder, stream, reader, writer, html, push;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
+          request = param.request, key = param.key, requestHandler = param.requestHandler, requestHandlerOptions = param.requestHandlerOptions, ttl = param.ttl, container = param.container, cacheStatus = param.cacheStatus;
           return [
             4,
-            render(ssrContext)
+            requestHandler(request, requestHandlerOptions)
           ];
         case 1:
-          renderResult = _state.sent();
-          if (!!renderResult)
-            return [
-              3,
-              2
-            ];
-          return [
-            2,
-            {
-              data: ""
-            }
-          ];
-        case 2:
-          if (!(typeof renderResult === "string"))
-            return [
-              3,
-              4
-            ];
-          current = Date.now();
-          cache = {
-            val: renderResult,
-            cursor: current
-          };
-          return [
-            4,
-            container.set(key, JSON.stringify(cache), {
-              ttl
-            })
-          ];
-        case 3:
-          _state.sent();
-          return [
-            2,
-            {
-              data: renderResult,
-              status
-            }
-          ];
-        case 4:
-          return [
-            4,
-            import("stream").catch(function(_) {
-              return {
-                Readable: void 0
-              };
-            })
-          ];
-        case 5:
-          Readable = _state.sent().Readable;
-          runtimeEnv = getRuntimeEnv();
-          streamModule = "../../adapters/node/polyfills/stream";
-          if (!(runtimeEnv === "node"))
+          response = _state.sent();
+          decoder = new TextDecoder();
+          if (response.body) {
+            stream = createTransformStream();
+            reader = response.body.getReader();
+            writer = stream.writable.getWriter();
+            html = "";
+            push = function() {
+              return reader.read().then(function(param2) {
+                var done = param2.done, value = param2.value;
+                if (done) {
+                  var current = Date.now();
+                  var cache = {
+                    val: html,
+                    cursor: current
+                  };
+                  container.set(key, JSON.stringify(cache), {
+                    ttl
+                  });
+                  writer.close();
+                  return;
+                }
+                var content = decoder.decode(value);
+                html += content;
+                writer.write(value);
+                push();
+              });
+            };
+            push();
+            cacheStatus && response.headers.set(X_RENDER_CACHE, cacheStatus);
             return [
-              3,
-              7
+              2,
+              new Response(stream.readable, {
+                status: response.status,
+                headers: response.headers
+              })
             ];
-          return [
-            4,
-            import(streamModule).catch(function(_) {
-              return {
-                createReadableStreamFromReadable: void 0
-              };
-            })
-          ];
-        case 6:
-          _tmp = _state.sent();
-          return [
-            3,
-            8
-          ];
-        case 7:
-          _tmp = {
-            createReadableStreamFromReadable: void 0
-          };
-          _state.label = 8;
-        case 8:
-          createReadableStreamFromReadable = _tmp.createReadableStreamFromReadable;
-          body = // TODO: remove node:stream, move it to ssr entry.
-          Readable && _instanceof(renderResult, Readable) ? createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(renderResult) : renderResult;
-          html = "";
-          stream = createTransformStream(function(chunk) {
-            html += chunk;
-            return chunk;
-          });
-          reader = body.getReader();
-          writer = stream.writable.getWriter();
-          push = function() {
-            reader.read().then(function(param) {
-              var done = param.done, value = param.value;
-              if (done) {
-                var current2 = Date.now();
-                var cache2 = {
-                  val: html,
-                  cursor: current2
-                };
-                container.set(key, JSON.stringify(cache2), {
-                  ttl
-                });
-                writer.close();
-                return;
-              }
-              writer.write(value);
-              push();
-            });
-          };
-          push();
+          }
           return [
             2,
-            {
-              data: stream.readable,
-              status
-            }
-          ];
-        case 9:
-          return [
-            2
+            response
           ];
       }
     });
@@ -206,11 +133,11 @@ function getCacheResult(request, options) {
 }
 function _getCacheResult() {
   _getCacheResult = _async_to_generator(function(request, options) {
-    var cacheControl, render, ssrContext, _options_container, container, key, value, maxAge, staleWhileRevalidate, ttl, cache, interval;
+    var cacheControl, _options_container, container, requestHandler, requestHandlerOptions, key, value, maxAge, staleWhileRevalidate, ttl, cache, interval, cacheStatus, cacheStatus1;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          cacheControl = options.cacheControl, render = options.render, ssrContext = options.ssrContext, _options_container = options.container, container = _options_container === void 0 ? storage : _options_container;
+          cacheControl = options.cacheControl, _options_container = options.container, container = _options_container === void 0 ? storage : _options_container, requestHandler = options.requestHandler, requestHandlerOptions = options.requestHandlerOptions;
           key = computedKey(request, cacheControl);
           return [
             4,
@@ -224,32 +151,75 @@ function _getCacheResult() {
             cache = JSON.parse(value);
             interval = Date.now() - cache.cursor;
             if (interval <= maxAge) {
+              cacheStatus = "hit";
               return [
                 2,
-                {
-                  data: cache.val,
-                  status: "hit"
-                }
+                new Response(cache.val, {
+                  headers: _define_property({}, X_RENDER_CACHE, cacheStatus)
+                })
               ];
             } else if (interval <= staleWhileRevalidate + maxAge) {
-              processCache(key, render, ssrContext, ttl, container);
+              processCache({
+                key,
+                request,
+                requestHandler,
+                requestHandlerOptions,
+                ttl,
+                container
+              }).then(function() {
+                var _ref = _async_to_generator(function(response) {
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        return [
+                          4,
+                          response.text()
+                        ];
+                      case 1:
+                        _state2.sent();
+                        return [
+                          2
+                        ];
+                    }
+                  });
+                });
+                return function(response) {
+                  return _ref.apply(this, arguments);
+                };
+              }());
+              cacheStatus1 = "stale";
               return [
                 2,
-                {
-                  data: cache.val,
-                  status: "stale"
-                }
+                new Response(cache.val, {
+                  headers: _define_property({}, X_RENDER_CACHE, cacheStatus1)
+                })
               ];
             } else {
               return [
                 2,
-                processCache(key, render, ssrContext, ttl, container, "expired")
+                processCache({
+                  key,
+                  request,
+                  requestHandler,
+                  requestHandlerOptions,
+                  ttl,
+                  container,
+                  cacheStatus: "expired"
+                })
               ];
             }
           } else {
             return [
               2,
-              processCache(key, render, ssrContext, ttl, container, "miss")
+              processCache({
+                key,
+                request,
+                requestHandler,
+                requestHandlerOptions,
+                ttl,
+                container,
+                cacheStatus: "miss"
+              })
             ];
           }
           return [