@modern-js/server-core 2.54.6 → 2.56.0

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 [

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/error.js

@@ -15,11 +15,11 @@ var ErrorDigest;
   ErrorDigest2["EINTER"] = "Internal server error";
   ErrorDigest2["ERENDER"] = "SSR render failed";
 })(ErrorDigest || (ErrorDigest = {}));
-function onError(digest, error, logger, req) {
+function onError(digest, error, monitors, req) {
   var headerData = req && parseHeaders(req);
   headerData && delete headerData.cookie;
-  if (logger) {
-    logger.error(req ? "Server Error - ".concat(digest, ", error = %s, req.url = %s, req.headers = %o") : "Server Error - ".concat(digest, ", error = %s"), _instanceof(error, Error) ? error.stack || error.message : error, req === null || req === void 0 ? void 0 : req.url, headerData);
+  if (monitors) {
+    monitors.error(req ? "Server Error - ".concat(digest, ", error = %s, req.url = %s, req.headers = %o") : "Server Error - ".concat(digest, ", error = %s"), _instanceof(error, Error) ? error.stack || error.message : error, req === null || req === void 0 ? void 0 : req.url, headerData);
   } else if (req) {
     console.error("Server Error - ".concat(digest, ", error = ").concat(_instanceof(error, Error) ? error.stack || error.message : error, ", req.url = ").concat(req.url, ", req.headers = ").concat(JSON.stringify(headerData)));
   } else {

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/adapters/node/plugins/resource.js

@@ -40,7 +40,7 @@ const loadBundle = async (filepath, logger) => {
     return void 0;
   }
   return dynamicImport(filepath).catch((e) => {
-    logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
+    logger === null || logger === void 0 ? void 0 : logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
     return void 0;
   });
 };