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

package/dist/esm/base/adapters/node/loadServer.js

@@ -0,0 +1,73 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { fs, dotenv, dotenvExpand } from "@modern-js/utils";
+function loadServerEnv(options) {
+  return _loadServerEnv.apply(this, arguments);
+}
+function _loadServerEnv() {
+  _loadServerEnv = _async_to_generator(function(options) {
+    var pwd, serverEnv, defaultEnvPath, serverEnvPath, _i, _iter, envPath, _tmp, envConfig;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          pwd = options.pwd;
+          serverEnv = process.env.MODERN_ENV;
+          defaultEnvPath = path.resolve(pwd, ".env");
+          serverEnvPath = path.resolve(pwd, ".env.".concat(serverEnv));
+          _i = 0, _iter = [
+            serverEnvPath,
+            defaultEnvPath
+          ];
+          _state.label = 1;
+        case 1:
+          if (!(_i < _iter.length))
+            return [
+              3,
+              6
+            ];
+          envPath = _iter[_i];
+          return [
+            4,
+            fs.pathExists(envPath)
+          ];
+        case 2:
+          _tmp = _state.sent();
+          if (!_tmp)
+            return [
+              3,
+              4
+            ];
+          return [
+            4,
+            fs.stat(envPath)
+          ];
+        case 3:
+          _tmp = !_state.sent().isDirectory();
+          _state.label = 4;
+        case 4:
+          if (_tmp) {
+            envConfig = dotenv.config({
+              path: envPath
+            });
+            dotenvExpand(envConfig);
+          }
+          _state.label = 5;
+        case 5:
+          _i++;
+          return [
+            3,
+            1
+          ];
+        case 6:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _loadServerEnv.apply(this, arguments);
+}
+export {
+  loadServerEnv
+};

package/dist/esm/base/adapters/node/middlewares/index.js

@@ -0,0 +1,4 @@
+export * from "./mock";
+export * from "./serverStatic";
+export * from "./templates";
+export * from "./serverManifest";

package/dist/esm/base/adapters/node/middlewares/mock.js

@@ -0,0 +1,198 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "node:path";
+import { fs } from "@modern-js/utils";
+import { AGGRED_DIR } from "../../../constants";
+import { connectMid2HonoMid } from "../hono";
+var parseKey = function(key) {
+  var _blank = " ";
+  var splitted = key.split(_blank).filter(Boolean);
+  if (splitted.length > 1) {
+    var _splitted = _sliced_to_array(splitted, 2), method = _splitted[0], pathname = _splitted[1];
+    return {
+      method: method.toLowerCase(),
+      path: pathname
+    };
+  }
+  return {
+    method: "get",
+    path: key
+  };
+};
+var mockHandlerRegistry = /* @__PURE__ */ new Map();
+var registerMockHandlers = function() {
+  var _ref = _async_to_generator(function(param) {
+    var pwd, server, exts, mockFilePath, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, ext, maybeMatch, err, _ref2, mockModule, config, enable;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          pwd = param.pwd, server = param.server;
+          exts = [
+            ".ts",
+            ".js"
+          ];
+          mockFilePath = "";
+          _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            6,
+            7,
+            8
+          ]);
+          _iterator = exts[Symbol.iterator]();
+          _state.label = 2;
+        case 2:
+          if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
+            return [
+              3,
+              5
+            ];
+          ext = _step.value;
+          maybeMatch = path.join(pwd, "".concat(AGGRED_DIR.mock, "/index").concat(ext));
+          return [
+            4,
+            fs.pathExists(maybeMatch)
+          ];
+        case 3:
+          if (_state.sent()) {
+            mockFilePath = maybeMatch;
+            return [
+              3,
+              5
+            ];
+          }
+          _state.label = 4;
+        case 4:
+          _iteratorNormalCompletion = true;
+          return [
+            3,
+            2
+          ];
+        case 5:
+          return [
+            3,
+            8
+          ];
+        case 6:
+          err = _state.sent();
+          _didIteratorError = true;
+          _iteratorError = err;
+          return [
+            3,
+            8
+          ];
+        case 7:
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+          return [
+            7
+          ];
+        case 8:
+          if (!mockFilePath) {
+            return [
+              2,
+              null
+            ];
+          }
+          return [
+            4,
+            import(mockFilePath)
+          ];
+        case 9:
+          _ref2 = _state.sent(), mockModule = _ref2.default, config = _ref2.config;
+          enable = config === null || config === void 0 ? void 0 : config.enable;
+          if (enable === false) {
+            return [
+              2
+            ];
+          }
+          if (!mockModule) {
+            throw new Error("Mock file ".concat(mockFilePath, " parsed failed!"));
+          }
+          Object.entries(mockModule).forEach(function(param2) {
+            var _param = _sliced_to_array(param2, 2), key = _param[0], handler = _param[1];
+            var _parseKey = parseKey(key), method = _parseKey.method, _$path = _parseKey.path;
+            var methodName = method.toLowerCase();
+            var handlerId = "".concat(methodName, "-").concat(_$path);
+            mockHandlerRegistry.set(handlerId, {
+              handler,
+              isRegistered: false
+            });
+            if (typeof server[methodName] === "function") {
+              var mockHandler = function() {
+                var _ref3 = _async_to_generator(function(c, next) {
+                  var _mockHandlerRegistry_get, isEnabled, handler2;
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        if (typeof enable === "function") {
+                          isEnabled = enable(c.env.node.req, c.env.node.res);
+                          if (!isEnabled) {
+                            return [
+                              2,
+                              next()
+                            ];
+                          }
+                        }
+                        handler2 = (_mockHandlerRegistry_get = mockHandlerRegistry.get(handlerId)) === null || _mockHandlerRegistry_get === void 0 ? void 0 : _mockHandlerRegistry_get.handler;
+                        if (!(typeof handler2 === "function"))
+                          return [
+                            3,
+                            2
+                          ];
+                        return [
+                          4,
+                          connectMid2HonoMid(handler2)(c, next)
+                        ];
+                      case 1:
+                        _state2.sent();
+                        return [
+                          3,
+                          3
+                        ];
+                      case 2:
+                        return [
+                          2,
+                          c.json(handler2)
+                        ];
+                      case 3:
+                        return [
+                          2
+                        ];
+                    }
+                  });
+                });
+                return function mockHandler2(c, next) {
+                  return _ref3.apply(this, arguments);
+                };
+              }();
+              var handlerInfo = mockHandlerRegistry.get(handlerId);
+              if (handlerInfo && !(handlerInfo === null || handlerInfo === void 0 ? void 0 : handlerInfo.isRegistered)) {
+                server[methodName](_$path, mockHandler);
+                handlerInfo.isRegistered = true;
+              }
+            }
+          });
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function registerMockHandlers2(_) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  registerMockHandlers
+};

package/dist/esm/base/adapters/node/middlewares/serverManifest.js

@@ -0,0 +1,139 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY } from "@modern-js/utils";
+function getServerManifest(pwd, routes) {
+  return _getServerManifest.apply(this, arguments);
+}
+function _getServerManifest() {
+  _getServerManifest = _async_to_generator(function(pwd, routes) {
+    var loaderBundles, renderBundles, loadableUri, loadableStats, routesManifestUri, routeManifest;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          loaderBundles = {};
+          renderBundles = {};
+          return [
+            4,
+            Promise.all(routes.map(function() {
+              var _ref = _async_to_generator(function(route) {
+                var entryName, loaderBundlePath, renderBundlePath, dynamicImport;
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      entryName = route.entryName || MAIN_ENTRY_NAME;
+                      loaderBundlePath = path.join(pwd, SERVER_BUNDLE_DIRECTORY, "".concat(entryName, "-server-loaders.js"));
+                      renderBundlePath = path.join(pwd, route.bundle || "");
+                      dynamicImport = function(filePath) {
+                        try {
+                          var module = require(filePath);
+                          return Promise.resolve(module);
+                        } catch (e) {
+                          return Promise.reject(e);
+                        }
+                      };
+                      return [
+                        4,
+                        Promise.allSettled([
+                          dynamicImport(loaderBundlePath),
+                          dynamicImport(renderBundlePath)
+                        ]).then(function(results) {
+                          var _results_ = results[0], loaderStatus = _results_.status;
+                          if (loaderStatus === "fulfilled") {
+                            loaderBundles[entryName] = results[0].value;
+                          }
+                          var _results_1 = results[1], renderStatus = _results_1.status;
+                          if (renderStatus === "fulfilled") {
+                            renderBundles[entryName] = results[1].value;
+                          }
+                        })
+                      ];
+                    case 1:
+                      _state2.sent();
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(route) {
+                return _ref.apply(this, arguments);
+              };
+            }()))
+          ];
+        case 1:
+          _state.sent();
+          loadableUri = path.join(pwd, LOADABLE_STATS_FILE);
+          return [
+            4,
+            import(loadableUri).catch(function(_) {
+              return {};
+            })
+          ];
+        case 2:
+          loadableStats = _state.sent();
+          routesManifestUri = path.join(pwd, ROUTE_MANIFEST_FILE);
+          return [
+            4,
+            import(routesManifestUri).catch(function(_) {
+              return {};
+            })
+          ];
+        case 3:
+          routeManifest = _state.sent();
+          return [
+            2,
+            {
+              loaderBundles,
+              renderBundles,
+              loadableStats,
+              routeManifest
+            }
+          ];
+      }
+    });
+  });
+  return _getServerManifest.apply(this, arguments);
+}
+function injectServerManifest(pwd, routes) {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var serverManifest;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            if (!(routes && !c.get("serverManifest")))
+              return [
+                3,
+                2
+              ];
+            return [
+              4,
+              getServerManifest(pwd, routes)
+            ];
+          case 1:
+            serverManifest = _state.sent();
+            c.set("serverManifest", serverManifest);
+            _state.label = 2;
+          case 2:
+            return [
+              4,
+              next()
+            ];
+          case 3:
+            _state.sent();
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+export {
+  getServerManifest,
+  injectServerManifest
+};

package/dist/esm/base/adapters/node/middlewares/serverPublic.js

@@ -0,0 +1,85 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+import { getMimeType } from "hono/utils/mime";
+import { sortRoutes } from "../../../utils";
+function createPublicMiddleware(param) {
+  var pwd = param.pwd, routes = param.routes;
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var route, entryPath, filename, data, mimeType;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            route = matchRoute(c.req, routes);
+            if (!route)
+              return [
+                3,
+                2
+              ];
+            entryPath = route.entryPath;
+            filename = path.join(pwd, entryPath);
+            return [
+              4,
+              fileReader.readFile(filename, "buffer")
+            ];
+          case 1:
+            data = _state.sent();
+            mimeType = getMimeType(filename);
+            if (data !== null) {
+              if (mimeType) {
+                c.header("Content-Type", mimeType);
+              }
+              return [
+                2,
+                c.body(data, 200)
+              ];
+            }
+            _state.label = 2;
+          case 2:
+            return [
+              4,
+              next()
+            ];
+          case 3:
+            return [
+              2,
+              _state.sent()
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+function matchRoute(req, routes) {
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = routes.sort(sortRoutes)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var route = _step.value;
+      if (!route.isSSR && !route.isApi && route.entryPath.startsWith("public") && req.path.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;
+}
+export {
+  createPublicMiddleware
+};

package/dist/esm/base/adapters/node/middlewares/serverStatic.js

@@ -0,0 +1,119 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { fs } from "@modern-js/utils";
+import { getMimeType } from "hono/utils/mime";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+import { createErrorHtml } from "../../../utils";
+import { createPublicMiddleware } from "./serverPublic";
+function createStaticMiddleware(options) {
+  var pwd = options.pwd, routes = options.routes;
+  var prefix = options.output.assetPrefix || "/";
+  var _options_output = options.output, tmp = _options_output.distPath, _ref = tmp === void 0 ? {} : tmp, cssPath = _ref.css, jsPath = _ref.js, mediaPath = _ref.media;
+  var _options_html = options.html, favicon = _options_html.favicon, faviconByEntries = _options_html.faviconByEntries;
+  var favicons = prepareFavicons(favicon, faviconByEntries);
+  var staticFiles = [
+    cssPath,
+    jsPath,
+    mediaPath
+  ].filter(function(v) {
+    return Boolean(v);
+  });
+  var staticReg = [
+    "static/",
+    "upload/"
+  ].concat(_to_consumable_array(staticFiles));
+  var iconReg = [
+    "favicon.ico",
+    "icon.png"
+  ].concat(_to_consumable_array(favicons));
+  var regPrefix = prefix.endsWith("/") ? prefix : "".concat(prefix, "/");
+  var staticPathRegExp = new RegExp("^".concat(regPrefix, "(").concat(_to_consumable_array(staticReg).concat(_to_consumable_array(iconReg)).join("|"), ")"));
+  return function() {
+    var _ref2 = _async_to_generator(function(c, next) {
+      var pathname, hit, filepath, mimeType, stat, size, chunk;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            pathname = c.req.path;
+            hit = staticPathRegExp.test(pathname);
+            if (!hit)
+              return [
+                3,
+                4
+              ];
+            filepath = path.join(pwd, pathname.replace(prefix, function() {
+              return "";
+            }));
+            return [
+              4,
+              fs.pathExists(filepath)
+            ];
+          case 1:
+            if (!_state.sent()) {
+              return [
+                2,
+                c.html(createErrorHtml(404), 404)
+              ];
+            }
+            mimeType = getMimeType(filepath);
+            if (mimeType) {
+              c.header("Content-Type", mimeType);
+            }
+            return [
+              4,
+              fs.lstat(filepath)
+            ];
+          case 2:
+            stat = _state.sent();
+            size = stat.size;
+            return [
+              4,
+              fileReader.readFile(filepath, "buffer")
+            ];
+          case 3:
+            chunk = _state.sent();
+            c.header("Content-Length", String(size));
+            return [
+              2,
+              c.body(chunk, 200)
+            ];
+          case 4:
+            return [
+              2,
+              createPublicMiddleware({
+                pwd,
+                routes: routes || []
+              })(c, next)
+            ];
+          case 5:
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+}
+var prepareFavicons = function(favicon, faviconByEntries) {
+  var faviconNames = [];
+  if (favicon && typeof favicon === "string") {
+    faviconNames.push(favicon.substring(favicon.lastIndexOf("/") + 1));
+  }
+  if (faviconByEntries) {
+    Object.keys(faviconByEntries).forEach(function(f) {
+      var curFavicon = faviconByEntries[f];
+      if (curFavicon) {
+        faviconNames.push(curFavicon.substring(curFavicon.lastIndexOf("/") + 1));
+      }
+    });
+  }
+  return faviconNames;
+};
+export {
+  createStaticMiddleware
+};