@modern-js/server-core 2.48.1 → 2.48.3-alpha.0

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,163 @@
+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, 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") || {};
+            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,
+                serverManifest
+              })
+            ];
+          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, runner, customServer, cacheModuleName, ssrCache, pageRoutes, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, originUrlPath, entryName, urlPath, customServerHookMiddleware, customServerMiddleware, render;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          routes = options.routes, pwd = options.pwd;
+          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);
+          _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));
+              server.use(urlPath, customServerHookMiddleware);
+              customServerMiddleware = customServer.getServerMiddleware();
+              server.use(urlPath, customServerMiddleware);
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+          }
+          return [
+            4,
+            getRenderHandler(options)
+          ];
+        case 4:
+          render = _state.sent();
+          render && server.all("*", createRenderHandler(render));
+          _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,213 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { REPLACE_REG } from "../../../base/constants";
+import { createErrorHtml, sortRoutes, cutNameByHyphen, 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, 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;
+                  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) {
+                    throw new Error("Can't found entry ".concat(routeInfo.entryName, " html "));
+                  }
+                  renderMode = getRenderMode(req, metaName || "modern-js", routeInfo.isSSR, forceCSR);
+                  renderOptions = {
+                    pwd,
+                    html,
+                    routeInfo,
+                    staticGenerate: staticGenerate || false,
+                    metaName: metaName || "modern-js",
+                    nonce,
+                    logger,
+                    nodeReq,
+                    reporter,
+                    serverRoutes: routes,
+                    serverManifest
+                  };
+                  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) {
+  var query = parseQuery(req);
+  if (isSSR) {
+    if (query.__loader) {
+      return "data";
+    }
+    if (forceCSR && (query.csr || req.headers.get("x-".concat(cutNameByHyphen(framework), "-ssr-fallback")))) {
+      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
+};