@modern-js/server-core 2.48.6 → 2.49.1-alpha.0

package/dist/esm/base/middlewares/logger.js

@@ -0,0 +1,75 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { getPathname } from "../utils";
+var LogPrefix;
+(function(LogPrefix2) {
+  LogPrefix2["Outgoing"] = "-->";
+  LogPrefix2["Incoming"] = "<--";
+  LogPrefix2["Error"] = "xxx";
+})(LogPrefix || (LogPrefix = {}));
+var humanize = function(times) {
+  var delimiter = ",", separator = ".";
+  var orderTimes = times.map(function(v) {
+    return v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1".concat(delimiter));
+  });
+  return orderTimes.join(separator);
+};
+var time = function(start) {
+  var delta = Date.now() - start;
+  return humanize([
+    delta < 1e3 ? "".concat(delta, "ms") : "".concat(Math.round(delta / 1e3), "s")
+  ]);
+};
+var colorStatus = function(status) {
+  var out = {
+    7: "\x1B[35m".concat(status, "\x1B[0m"),
+    5: "\x1B[31m".concat(status, "\x1B[0m"),
+    4: "\x1B[33m".concat(status, "\x1B[0m"),
+    3: "\x1B[36m".concat(status, "\x1B[0m"),
+    2: "\x1B[32m".concat(status, "\x1B[0m"),
+    1: "\x1B[32m".concat(status, "\x1B[0m"),
+    0: "\x1B[33m".concat(status, "\x1B[0m")
+  };
+  var calculateStatus = Math.floor(status / 100);
+  return out[calculateStatus];
+};
+function log(fn, prefix, method, path) {
+  var status = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : 0, elapsed = arguments.length > 5 ? arguments[5] : void 0;
+  var out = prefix === "<--" ? "  ".concat(prefix, " ").concat(method, " ").concat(path) : "  ".concat(prefix, " ").concat(method, " ").concat(path, " ").concat(colorStatus(status), " ").concat(elapsed);
+  fn(out);
+}
+function logHandler() {
+  return function() {
+    var _logger = _async_to_generator(function(c, next) {
+      var method, _$logger, path, logFn, start;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            method = c.req.method;
+            _$logger = c.get("logger");
+            path = getPathname(c.req.raw);
+            logFn = _$logger.debug;
+            log(logFn, "<--", method, path);
+            start = Date.now();
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            log(logFn, "-->", method, path, c.res.status, time(start));
+            return [
+              2
+            ];
+        }
+      });
+    });
+    function logger(c, next) {
+      return _logger.apply(this, arguments);
+    }
+    return logger;
+  }();
+}
+export {
+  logHandler
+};

package/dist/esm/base/middlewares/monitor.js

@@ -0,0 +1,157 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { time } from "@modern-js/runtime-utils/time";
+import { ServerReportTimings } from "../constants";
+var defaultReporter = {
+  init: function init() {
+  },
+  reportError: function reportError() {
+  },
+  reportTiming: function reportTiming() {
+  },
+  reportInfo: function reportInfo() {
+  },
+  reportWarn: function reportWarn() {
+  }
+};
+function injectReporter() {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var reporter;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            reporter = c.get("reporter");
+            if (!reporter) {
+              c.set("reporter", defaultReporter);
+            }
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+function initReporter(entryName) {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var reporter, getCost, cost;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            reporter = c.get("reporter");
+            if (!!reporter)
+              return [
+                3,
+                2
+              ];
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+          case 2:
+            return [
+              4,
+              reporter.init({
+                entryName
+              })
+            ];
+          case 3:
+            _state.sent();
+            getCost = time();
+            return [
+              4,
+              next()
+            ];
+          case 4:
+            _state.sent();
+            cost = getCost();
+            reporter.reportTiming(ServerReportTimings.SERVER_HANDLE_REQUEST, cost);
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+function injectLogger(inputLogger) {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var logger;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            logger = c.get("logger");
+            if (!logger && inputLogger) {
+              c.set("logger", inputLogger);
+            }
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+function injectMetrics(inputMetrics) {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var metrics;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            metrics = c.get("metrics");
+            if (!metrics) {
+              c.set("metrics", inputMetrics);
+            }
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+export {
+  initReporter,
+  injectLogger,
+  injectMetrics,
+  injectReporter
+};

package/dist/esm/base/middlewares/renderHandler/dataHandler.js

@@ -0,0 +1,45 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+var dataHandler = function() {
+  var _ref = _async_to_generator(function(request, param) {
+    var routeInfo, serverRoutes, reporter, logger, serverManifest, _serverManifest_loaderBundles, serverLoaderModule, routes, handleRequest, response;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          routeInfo = param.routeInfo, serverRoutes = param.serverRoutes, reporter = param.reporter, logger = param.logger, serverManifest = param.serverManifest;
+          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) {
+            return [
+              2
+            ];
+          }
+          routes = serverLoaderModule.routes, handleRequest = serverLoaderModule.handleRequest;
+          return [
+            4,
+            handleRequest({
+              request,
+              serverRoutes,
+              context: {
+                logger,
+                reporter
+              },
+              routes
+            })
+          ];
+        case 1:
+          response = _state.sent();
+          return [
+            2,
+            response
+          ];
+      }
+    });
+  });
+  return function dataHandler2(request, _) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  dataHandler
+};

package/dist/esm/base/middlewares/renderHandler/index.js

@@ -0,0 +1,167 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { checkIsProd, sortRoutes, getRuntimeEnv } from "../../utils";
+import { initReporter } from "../monitor";
+import { CustomServer } from "../customServer";
+import { createRender } from "./render";
+function createRenderHandler(render) {
+  return function() {
+    var _ref = _async_to_generator(function(c, _) {
+      var _c_env_node, logger, reporter, templates, serverManifest, locals, metrics, request, nodeReq, res;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            logger = c.get("logger");
+            reporter = c.get("reporter");
+            templates = c.get("templates") || {};
+            serverManifest = c.get("serverManifest") || {};
+            locals = c.get("locals");
+            metrics = c.get("metrics");
+            request = c.req.raw;
+            nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
+            return [
+              4,
+              render(request, {
+                logger,
+                nodeReq,
+                reporter,
+                templates,
+                metrics,
+                serverManifest,
+                locals
+              })
+            ];
+          case 1:
+            res = _state.sent();
+            return [
+              2,
+              res
+            ];
+        }
+      });
+    });
+    return function(c, _) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+function getRenderHandler(options) {
+  return _getRenderHandler.apply(this, arguments);
+}
+function _getRenderHandler() {
+  _getRenderHandler = _async_to_generator(function(options) {
+    var routes, pwd, config, _config_server, _options_config_security, ssrConfig, forceCSR, render;
+    return _ts_generator(this, function(_state) {
+      routes = options.routes, pwd = options.pwd, config = options.config;
+      if (routes && routes.length > 0) {
+        ;
+        ssrConfig = (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr;
+        forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
+        render = createRender({
+          routes,
+          pwd,
+          staticGenerate: options.staticGenerate,
+          metaName: options.metaName || "modern-js",
+          forceCSR,
+          nonce: (_options_config_security = options.config.security) === null || _options_config_security === void 0 ? void 0 : _options_config_security.nonce
+        });
+        return [
+          2,
+          render
+        ];
+      }
+      return [
+        2,
+        null
+      ];
+    });
+  });
+  return _getRenderHandler.apply(this, arguments);
+}
+function bindRenderHandler(server, options) {
+  return _bindRenderHandler.apply(this, arguments);
+}
+function _bindRenderHandler() {
+  _bindRenderHandler = _async_to_generator(function(server, options) {
+    var routes, pwd, disableCustomHook, runner, customServer, cacheModuleName, ssrCache, pageRoutes, render, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, originUrlPath, entryName, urlPath, customServerHookMiddleware, customServerMiddleware;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          routes = options.routes, pwd = options.pwd, disableCustomHook = options.disableCustomHook;
+          runner = server.runner;
+          if (!(routes && routes.length > 0))
+            return [
+              3,
+              5
+            ];
+          customServer = new CustomServer(runner, server, pwd);
+          if (!(getRuntimeEnv() === "node"))
+            return [
+              3,
+              3
+            ];
+          cacheModuleName = "./ssrCache";
+          return [
+            4,
+            import(cacheModuleName)
+          ];
+        case 1:
+          ssrCache = _state.sent().ssrCache;
+          return [
+            4,
+            ssrCache.loadCacheMod(checkIsProd() ? pwd : void 0)
+          ];
+        case 2:
+          _state.sent();
+          _state.label = 3;
+        case 3:
+          pageRoutes = routes.filter(function(route2) {
+            return !route2.isApi;
+          }).sort(sortRoutes);
+          return [
+            4,
+            getRenderHandler(options)
+          ];
+        case 4:
+          render = _state.sent();
+          _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+          try {
+            for (_iterator = pageRoutes[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+              route = _step.value;
+              originUrlPath = route.urlPath, entryName = route.entryName;
+              urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
+              customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
+              server.use(urlPath, initReporter(entryName));
+              !disableCustomHook && server.use(urlPath, customServerHookMiddleware);
+              customServerMiddleware = customServer.getServerMiddleware();
+              server.use(urlPath, customServerMiddleware);
+              render && server.all(urlPath, createRenderHandler(render));
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+          }
+          _state.label = 5;
+        case 5:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _bindRenderHandler.apply(this, arguments);
+}
+export {
+  bindRenderHandler,
+  getRenderHandler
+};

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

@@ -0,0 +1,225 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { cutNameByHyphen } from "@modern-js/utils/universal";
+import { REPLACE_REG } from "../../../base/constants";
+import { createErrorHtml, sortRoutes, parseQuery, transformResponse, getPathname } from "../../utils";
+import { dataHandler } from "./dataHandler";
+import { ssrRender } from "./ssrRender";
+function createRender(_) {
+  return _createRender.apply(this, arguments);
+}
+function _createRender() {
+  _createRender = _async_to_generator(function(param) {
+    var routes, pwd, metaName, staticGenerate, forceCSR, nonce;
+    return _ts_generator(this, function(_state) {
+      routes = param.routes, pwd = param.pwd, metaName = param.metaName, staticGenerate = param.staticGenerate, forceCSR = param.forceCSR, nonce = param.nonce;
+      return [
+        2,
+        function() {
+          var _ref = _async_to_generator(function(req, param2) {
+            var logger, nodeReq, reporter, templates, serverManifest, locals, metrics, routeInfo, html, renderMode, renderOptions, response;
+            return _ts_generator(this, function(_state2) {
+              switch (_state2.label) {
+                case 0:
+                  logger = param2.logger, nodeReq = param2.nodeReq, reporter = param2.reporter, templates = param2.templates, serverManifest = param2.serverManifest, locals = param2.locals, metrics = param2.metrics;
+                  routeInfo = matchRoute(req, routes);
+                  if (!routeInfo) {
+                    return [
+                      2,
+                      new Response(createErrorHtml(404), {
+                        status: 404,
+                        headers: {
+                          "content-type": "text/html; charset=UTF-8"
+                        }
+                      })
+                    ];
+                  }
+                  html = templates[routeInfo.entryName];
+                  if (!html) {
+                    return [
+                      2,
+                      new Response(createErrorHtml(404), {
+                        status: 404,
+                        headers: {
+                          "content-type": "text/html; charset=UTF-8"
+                        }
+                      })
+                    ];
+                  }
+                  renderMode = getRenderMode(req, metaName || "modern-js", routeInfo.isSSR, forceCSR, nodeReq);
+                  renderOptions = {
+                    pwd,
+                    html,
+                    routeInfo,
+                    staticGenerate: staticGenerate || false,
+                    metaName: metaName || "modern-js",
+                    nonce,
+                    logger,
+                    nodeReq,
+                    reporter,
+                    serverRoutes: routes,
+                    locals,
+                    serverManifest,
+                    metrics
+                  };
+                  switch (renderMode) {
+                    case "data":
+                      return [
+                        3,
+                        1
+                      ];
+                    case "ssr":
+                      return [
+                        3,
+                        5
+                      ];
+                    case "csr":
+                      return [
+                        3,
+                        5
+                      ];
+                  }
+                  return [
+                    3,
+                    6
+                  ];
+                case 1:
+                  return [
+                    4,
+                    dataHandler(req, renderOptions)
+                  ];
+                case 2:
+                  response = _state2.sent();
+                  if (!!response)
+                    return [
+                      3,
+                      4
+                    ];
+                  return [
+                    4,
+                    renderHandler(req, renderOptions, "ssr")
+                  ];
+                case 3:
+                  response = _state2.sent();
+                  _state2.label = 4;
+                case 4:
+                  return [
+                    2,
+                    response
+                  ];
+                case 5:
+                  return [
+                    2,
+                    renderHandler(req, renderOptions, renderMode)
+                  ];
+                case 6:
+                  throw new Error("Unknown render mode: ".concat(renderMode));
+                case 7:
+                  return [
+                    2
+                  ];
+              }
+            });
+          });
+          return function(req, _) {
+            return _ref.apply(this, arguments);
+          };
+        }()
+      ];
+    });
+  });
+  return _createRender.apply(this, arguments);
+}
+function renderHandler(request, options, mode) {
+  return _renderHandler.apply(this, arguments);
+}
+function _renderHandler() {
+  _renderHandler = _async_to_generator(function(request, options, mode) {
+    var serverData, response;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          serverData = {
+            router: {
+              baseUrl: options.routeInfo.urlPath,
+              params: {}
+            }
+          };
+          return [
+            4,
+            mode === "ssr" ? ssrRender(request, options) : csrRender(options.html)
+          ];
+        case 1:
+          response = _state.sent();
+          return [
+            2,
+            transformResponse(response, injectServerData(serverData))
+          ];
+      }
+    });
+  });
+  return _renderHandler.apply(this, arguments);
+}
+function matchRoute(req, routes) {
+  var sorted = routes.sort(sortRoutes);
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = sorted[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var route = _step.value;
+      var pathname = getPathname(req);
+      if (pathname.startsWith(route.urlPath)) {
+        return route;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return void 0;
+}
+function getRenderMode(req, framework, isSSR, forceCSR, nodeReq) {
+  var query = parseQuery(req);
+  var fallbackHeader = "x-".concat(cutNameByHyphen(framework), "-ssr-fallback");
+  if (isSSR) {
+    if (query.__loader) {
+      return "data";
+    }
+    if (forceCSR && (query.csr || req.headers.get(fallbackHeader) || (nodeReq === null || nodeReq === void 0 ? void 0 : nodeReq.headers[fallbackHeader]))) {
+      return "csr";
+    }
+    return "ssr";
+  } else {
+    return "csr";
+  }
+}
+function csrRender(html) {
+  return new Response(html, {
+    status: 200,
+    headers: new Headers({
+      "content-type": "text/html; charset=UTF-8"
+    })
+  });
+}
+function injectServerData(serverData) {
+  var head = REPLACE_REG.before.head;
+  var searchValue = new RegExp(head);
+  var replcaeCb = function(beforeHead) {
+    return "".concat(beforeHead, '<script type="application/json" id="__MODERN_SERVER_DATA__">').concat(JSON.stringify(serverData), "</script>");
+  };
+  return function(template) {
+    return template.replace(searchValue, replcaeCb);
+  };
+}
+export {
+  createRender
+};

package/dist/esm/base/middlewares/renderHandler/serverTiming.js

@@ -0,0 +1,21 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+var SERVER_TIMING = "Server-Timing";
+var ServerTiming = /* @__PURE__ */ function() {
+  "use strict";
+  function ServerTiming2(headers, meta) {
+    _class_call_check(this, ServerTiming2);
+    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);
+    return this;
+  };
+  return ServerTiming2;
+}();
+export {
+  ServerTiming
+};