@modern-js/server-core 2.53.0 → 2.54.0

package/dist/cjs/adapters/node/helper/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var helper_exports = {};
+__export(helper_exports, {
+  loadCacheConfig: () => import_loadCache.loadCacheConfig,
+  loadServerConfig: () => import_loadConfig.loadServerConfig,
+  loadServerEnv: () => import_loadEnv.loadServerEnv,
+  loadServerPlugins: () => import_loadPlugin.loadServerPlugins
+});
+module.exports = __toCommonJS(helper_exports);
+var import_loadEnv = require("./loadEnv");
+var import_loadPlugin = require("./loadPlugin");
+var import_loadConfig = require("./loadConfig");
+var import_loadCache = require("./loadCache");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadCacheConfig,
+  loadServerConfig,
+  loadServerEnv,
+  loadServerPlugins
+});

package/dist/cjs/{base/adapters/node/middlewares/templates.js → adapters/node/helper/loadCache.js}

@@ -26,42 +26,28 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var templates_exports = {};
-__export(templates_exports, {
-  getHtmlTemplates: () => getHtmlTemplates,
-  injectTemplates: () => injectTemplates
+var loadCache_exports = {};
+__export(loadCache_exports, {
+  loadCacheConfig: () => loadCacheConfig
 });
-module.exports = __toCommonJS(templates_exports);
+module.exports = __toCommonJS(loadCache_exports);
 var import_path = __toESM(require("path"));
-var import_fileReader = require("@modern-js/runtime-utils/fileReader");
-async function getHtmlTemplates(pwd, routes) {
-  const htmls = await Promise.all(routes.map(async (route) => {
-    let html;
-    try {
-      var _this;
-      const htmlPath = import_path.default.join(pwd, route.entryPath);
-      html = (_this = await import_fileReader.fileReader.readFile(htmlPath, "utf-8")) === null || _this === void 0 ? void 0 : _this.toString();
-    } catch (e) {
-    }
-    return [
-      route.entryName,
-      html
-    ];
-  }) || []);
-  const templates = Object.fromEntries(htmls);
-  return templates;
-}
-function injectTemplates(pwd, routes) {
-  return async (c, next) => {
-    if (routes && !c.get("templates")) {
-      const templates = await getHtmlTemplates(pwd, routes);
-      c.set("templates", templates);
-    }
-    await next();
-  };
+var import_utils = require("@modern-js/utils");
+const CACHE_FILENAME = "cache";
+function loadCacheConfig(pwd) {
+  const serverCacheFilepath = import_path.default.resolve(pwd, import_utils.SERVER_DIR, CACHE_FILENAME);
+  const mod = (0, import_utils.requireExistModule)(serverCacheFilepath, {
+    interop: false
+  });
+  if (mod === null || mod === void 0 ? void 0 : mod.cacheOption) {
+    return {
+      strategy: mod.cacheOption,
+      container: mod.customContainer
+    };
+  }
+  return void 0;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getHtmlTemplates,
-  injectTemplates
+  loadCacheConfig
 });

package/dist/cjs/{base/utils/serverConfig.js → adapters/node/helper/loadConfig.js}

@@ -26,45 +26,40 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var serverConfig_exports = {};
-__export(serverConfig_exports, {
-  getServerConfigPath: () => getServerConfigPath,
-  loadConfig: () => loadConfig,
-  requireConfig: () => requireConfig
+var loadConfig_exports = {};
+__export(loadConfig_exports, {
+  loadServerConfig: () => loadServerConfig
 });
-module.exports = __toCommonJS(serverConfig_exports);
+module.exports = __toCommonJS(loadConfig_exports);
+var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
-var import_merge_deep = __toESM(require("merge-deep"));
-const getServerConfigPath = async (distDirectory, serverConfigFile = import_utils.DEFAULT_SERVER_CONFIG) => {
-  const path = await Promise.resolve().then(() => __toESM(require("path")));
-  const serverConfigPath = path.join(distDirectory, serverConfigFile);
-  return `${serverConfigPath}.js`;
-};
 const requireConfig = (serverConfigPath) => {
   if (import_utils.fs.pathExistsSync(serverConfigPath)) {
     return (0, import_utils.compatRequire)(serverConfigPath);
   }
-  return {};
+  return void 0;
 };
-const loadConfig = ({ cliConfig, serverConfig, resolvedConfigPath }) => {
-  let config = null;
-  if (process.env.NODE_ENV === "production") {
-    const resolvedConfig = requireConfig(resolvedConfigPath);
-    config = (0, import_merge_deep.default)({
-      ...resolvedConfig,
-      plugins: []
-    }, serverConfig, cliConfig);
-  } else {
-    config = (0, import_merge_deep.default)({
-      ...cliConfig,
-      plugins: []
-    }, serverConfig);
+function loadServerConfigNew(serverConfigPath) {
+  const mod = (0, import_utils.requireExistModule)(serverConfigPath);
+  if (mod) {
+    return mod;
   }
-  return config;
-};
+  return void 0;
+}
+function loadServerConfigOld(pwd, configFile) {
+  const serverConfigPath = import_path.default.join(pwd, `${configFile}.js`);
+  const serverConfig = requireConfig(serverConfigPath);
+  return serverConfig;
+}
+function loadServerConfig(pwd, oldServerFile = import_utils.DEFAULT_SERVER_CONFIG, newServerConfigPath) {
+  const newServerConfig = newServerConfigPath && loadServerConfigNew(newServerConfigPath);
+  if (newServerConfig) {
+    return newServerConfig;
+  }
+  const oldServerConfig = loadServerConfigOld(pwd, oldServerFile);
+  return oldServerConfig;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getServerConfigPath,
-  loadConfig,
-  requireConfig
+  loadServerConfig
 });

package/dist/cjs/{base/adapters/node/loadServer.js → adapters/node/helper/loadEnv.js}

@@ -26,11 +26,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var loadServer_exports = {};
-__export(loadServer_exports, {
+var loadEnv_exports = {};
+__export(loadEnv_exports, {
   loadServerEnv: () => loadServerEnv
 });
-module.exports = __toCommonJS(loadServer_exports);
+module.exports = __toCommonJS(loadEnv_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 async function loadServerEnv(options) {

package/dist/cjs/{base/utils/debug.js → adapters/node/helper/loadPlugin.js}

@@ -16,14 +16,24 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var debug_exports = {};
-__export(debug_exports, {
-  debug: () => debug
+var loadPlugin_exports = {};
+__export(loadPlugin_exports, {
+  loadServerPlugins: () => loadServerPlugins
 });
-module.exports = __toCommonJS(debug_exports);
+module.exports = __toCommonJS(loadPlugin_exports);
 var import_utils = require("@modern-js/utils");
-const debug = (0, import_utils.createDebugger)("prod-server");
+function resolveServerPlugin(plugin, appDirectory) {
+  const { name, options } = plugin;
+  const pluginPath = (0, import_utils.tryResolve)(name, appDirectory);
+  const module2 = (0, import_utils.compatRequire)(pluginPath);
+  const pluginInstance = module2(options);
+  return pluginInstance;
+}
+function loadServerPlugins(serverPlugins, appDirectory) {
+  const instances = serverPlugins.map((plugin) => resolveServerPlugin(plugin, appDirectory));
+  return instances;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  debug
+  loadServerPlugins
 });

package/dist/cjs/{base/adapters → adapters}/node/index.js

@@ -18,41 +18,42 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var node_exports = {};
 __export(node_exports, {
-  bindBFFHandler: () => import_bff.bindBFFHandler,
   connectMid2HonoMid: () => import_hono.connectMid2HonoMid,
   createNodeServer: () => import_node.createNodeServer,
-  createStaticMiddleware: () => import_middlewares.createStaticMiddleware,
   createWebRequest: () => import_node.createWebRequest,
-  getHtmlTemplates: () => import_middlewares.getHtmlTemplates,
-  getServerManifest: () => import_middlewares.getServerManifest,
+  getHtmlTemplates: () => import_plugins.getHtmlTemplates,
+  getServerManifest: () => import_plugins.getServerManifest,
   httpCallBack2HonoMid: () => import_hono.httpCallBack2HonoMid,
-  injectServerManifest: () => import_middlewares.injectServerManifest,
-  injectTemplates: () => import_middlewares.injectTemplates,
-  loadServerEnv: () => import_loadServer.loadServerEnv,
-  registerMockHandlers: () => import_middlewares.registerMockHandlers,
+  injectNodeSeverPlugin: () => import_plugins.injectNodeSeverPlugin,
+  injectResourcePlugin: () => import_plugins.injectResourcePlugin,
+  loadCacheConfig: () => import_helper.loadCacheConfig,
+  loadServerConfig: () => import_helper.loadServerConfig,
+  loadServerEnv: () => import_helper.loadServerEnv,
+  loadServerPlugins: () => import_helper.loadServerPlugins,
   sendResponse: () => import_node.sendResponse,
+  serverStaticPlugin: () => import_plugins.serverStaticPlugin,
   writeReadableStreamToWritable: () => import_node.writeReadableStreamToWritable
 });
 module.exports = __toCommonJS(node_exports);
-var import_loadServer = require("./loadServer");
 var import_hono = require("./hono");
 var import_node = require("./node");
-var import_bff = require("./bff");
-var import_middlewares = require("./middlewares");
+var import_plugins = require("./plugins");
+var import_helper = require("./helper");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  bindBFFHandler,
   connectMid2HonoMid,
   createNodeServer,
-  createStaticMiddleware,
   createWebRequest,
   getHtmlTemplates,
   getServerManifest,
   httpCallBack2HonoMid,
-  injectServerManifest,
-  injectTemplates,
+  injectNodeSeverPlugin,
+  injectResourcePlugin,
+  loadCacheConfig,
+  loadServerConfig,
   loadServerEnv,
-  registerMockHandlers,
+  loadServerPlugins,
   sendResponse,
+  serverStaticPlugin,
   writeReadableStreamToWritable
 });

package/dist/cjs/{core → adapters/node/plugins}/index.js

@@ -13,10 +13,14 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var core_exports = {};
-module.exports = __toCommonJS(core_exports);
-__reExport(core_exports, require("./plugin"), module.exports);
+var plugins_exports = {};
+module.exports = __toCommonJS(plugins_exports);
+__reExport(plugins_exports, require("./static"), module.exports);
+__reExport(plugins_exports, require("./resource"), module.exports);
+__reExport(plugins_exports, require("./nodeServer"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./plugin")
+  ...require("./static"),
+  ...require("./resource"),
+  ...require("./nodeServer")
 });

package/dist/cjs/{base/middlewares/frameworkHeader.js → adapters/node/plugins/nodeServer.js}

@@ -16,16 +16,23 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var frameworkHeader_exports = {};
-__export(frameworkHeader_exports, {
-  processedBy: () => processedBy
+var nodeServer_exports = {};
+__export(nodeServer_exports, {
+  injectNodeSeverPlugin: () => injectNodeSeverPlugin
+});
+module.exports = __toCommonJS(nodeServer_exports);
+const injectNodeSeverPlugin = ({ nodeServer }) => ({
+  name: "@modern-js/plugin-inject-node-server",
+  setup(api) {
+    const appContext = api.useAppContext();
+    api.setAppContext({
+      ...appContext,
+      nodeServer
+    });
+    return {};
+  }
 });
-module.exports = __toCommonJS(frameworkHeader_exports);
-const processedBy = async (ctx, next) => {
-  await next();
-  ctx.header("X-Processed-By", "Modern.js");
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  processedBy
+  injectNodeSeverPlugin
 });

package/dist/cjs/{base/adapters/node/middlewares/serverManifest.js → adapters/node/plugins/resource.js}

@@ -26,14 +26,44 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var serverManifest_exports = {};
-__export(serverManifest_exports, {
+var resource_exports = {};
+__export(resource_exports, {
+  getHtmlTemplates: () => getHtmlTemplates,
   getServerManifest: () => getServerManifest,
-  injectServerManifest: () => injectServerManifest
+  injectResourcePlugin: () => injectResourcePlugin,
+  injectServerManifest: () => injectServerManifest,
+  injectTemplates: () => injectTemplates
 });
-module.exports = __toCommonJS(serverManifest_exports);
+module.exports = __toCommonJS(resource_exports);
 var import_path = __toESM(require("path"));
+var import_fileReader = require("@modern-js/runtime-utils/fileReader");
 var import_utils = require("@modern-js/utils");
+async function getHtmlTemplates(pwd, routes) {
+  const htmls = await Promise.all(routes.map(async (route) => {
+    let html;
+    try {
+      var _this;
+      const htmlPath = import_path.default.join(pwd, route.entryPath);
+      html = (_this = await import_fileReader.fileReader.readFile(htmlPath, "utf-8")) === null || _this === void 0 ? void 0 : _this.toString();
+    } catch (e) {
+    }
+    return [
+      route.entryName,
+      html
+    ];
+  }) || []);
+  const templates = Object.fromEntries(htmls);
+  return templates;
+}
+function injectTemplates(pwd, routes) {
+  return async (c, next) => {
+    if (routes && !c.get("templates")) {
+      const templates = await getHtmlTemplates(pwd, routes);
+      c.set("templates", templates);
+    }
+    await next();
+  };
+}
 const dynamicImport = (filePath) => {
   try {
     const module2 = require(filePath);
@@ -84,8 +114,29 @@ function injectServerManifest(pwd, routes) {
     await next();
   };
 }
+const injectResourcePlugin = () => ({
+  name: "@modern-js/plugin-inject-resource",
+  setup(api) {
+    return {
+      async prepare() {
+        const { middlewares, routes, distDirectory: pwd } = api.useAppContext();
+        middlewares.push({
+          name: "inject-server-manifest",
+          handler: injectServerManifest(pwd, routes)
+        });
+        middlewares.push({
+          name: "inject-html",
+          handler: injectTemplates(pwd, routes)
+        });
+      }
+    };
+  }
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  getHtmlTemplates,
   getServerManifest,
-  injectServerManifest
+  injectResourcePlugin,
+  injectServerManifest,
+  injectTemplates
 });

package/dist/cjs/{base/adapters/node/middlewares/serverStatic.js → adapters/node/plugins/static.js}

@@ -26,16 +26,68 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var serverStatic_exports = {};
-__export(serverStatic_exports, {
-  createStaticMiddleware: () => createStaticMiddleware
+var static_exports = {};
+__export(static_exports, {
+  createPublicMiddleware: () => createPublicMiddleware,
+  createStaticMiddleware: () => createStaticMiddleware,
+  serverStaticPlugin: () => serverStaticPlugin
 });
-module.exports = __toCommonJS(serverStatic_exports);
+module.exports = __toCommonJS(static_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 var import_mime = require("hono/utils/mime");
 var import_fileReader = require("@modern-js/runtime-utils/fileReader");
-var import_serverPublic = require("./serverPublic");
+var import_utils2 = require("../../../utils");
+const serverStaticPlugin = () => ({
+  name: "@modern-js/plugin-server-static",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares, distDirectory: pwd, routes } = api.useAppContext();
+        const config = api.useConfigContext();
+        const serverStaticMiddleware = createStaticMiddleware({
+          pwd,
+          routes,
+          output: config.output || {},
+          html: config.html || {}
+        });
+        middlewares.push({
+          name: "server-static",
+          handler: serverStaticMiddleware
+        });
+      }
+    };
+  }
+});
+function createPublicMiddleware({ pwd, routes }) {
+  return async (c, next) => {
+    const route = matchRoute(c.req, routes);
+    if (route) {
+      const { entryPath } = route;
+      const filename = import_path.default.join(pwd, entryPath);
+      const data = await import_fileReader.fileReader.readFile(filename, "buffer");
+      const mimeType = (0, import_mime.getMimeType)(filename);
+      if (data !== null) {
+        if (mimeType) {
+          c.header("Content-Type", mimeType);
+        }
+        Object.entries(route.responseHeaders || {}).forEach(([k, v]) => {
+          c.header(k, v);
+        });
+        return c.body(data, 200);
+      }
+    }
+    return await next();
+  };
+}
+function matchRoute(req, routes) {
+  for (const route of routes.sort(import_utils2.sortRoutes)) {
+    if (!route.isSSR && route.entryPath.startsWith("public") && req.path.startsWith(route.urlPath)) {
+      return route;
+    }
+  }
+  return void 0;
+}
 function createStaticMiddleware(options) {
   const { pwd, routes } = options;
   const prefix = options.output.assetPrefix || "/";
@@ -80,7 +132,7 @@ function createStaticMiddleware(options) {
       c.header("Content-Length", String(size));
       return c.body(chunk, 200);
     } else {
-      return (0, import_serverPublic.createPublicMiddleware)({
+      return createPublicMiddleware({
         pwd,
         routes: routes || []
       })(c, next);
@@ -104,5 +156,7 @@ const prepareFavicons = (favicon, faviconByEntries) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createStaticMiddleware
+  createPublicMiddleware,
+  createStaticMiddleware,
+  serverStaticPlugin
 });

package/dist/cjs/{base/constants.js → constants.js}

@@ -21,6 +21,7 @@ __export(constants_exports, {
   AGGRED_DIR: () => AGGRED_DIR,
   REPLACE_REG: () => REPLACE_REG,
   ServerReportTimings: () => ServerReportTimings,
+  X_MODERNJS_RENDER: () => X_MODERNJS_RENDER,
   X_RENDER_CACHE: () => X_RENDER_CACHE
 });
 module.exports = __toCommonJS(constants_exports);
@@ -49,10 +50,12 @@ var ServerReportTimings;
   ServerReportTimings2["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
 })(ServerReportTimings || (ServerReportTimings = {}));
 const X_RENDER_CACHE = "x-render-cache";
+const X_MODERNJS_RENDER = "x-modernjs-render";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGGRED_DIR,
   REPLACE_REG,
   ServerReportTimings,
+  X_MODERNJS_RENDER,
   X_RENDER_CACHE
 });

package/dist/cjs/index.js

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -14,17 +18,35 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
+__export(src_exports, {
+  AGGRED_DIR: () => import_constants.AGGRED_DIR,
+  ErrorDigest: () => import_utils.ErrorDigest,
+  PluginManager: () => import_pluginManager.PluginManager,
+  createErrorHtml: () => import_utils.createErrorHtml,
+  createServerBase: () => import_serverBase.createServerBase,
+  onError: () => import_utils.onError
+});
 module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./core/plugin"), module.exports);
-__reExport(src_exports, require("./core/render"), module.exports);
+var import_utils = require("./utils");
+var import_constants = require("./constants");
+var import_serverBase = require("./serverBase");
+var import_pluginManager = require("./pluginManager");
+__reExport(src_exports, require("./plugins"), module.exports);
+__reExport(src_exports, require("./types/plugin"), module.exports);
+__reExport(src_exports, require("./types/render"), module.exports);
 __reExport(src_exports, require("@modern-js/plugin"), module.exports);
-__reExport(src_exports, require("./core/loadPlugins"), module.exports);
 __reExport(src_exports, require("./types/config"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./core/plugin"),
-  ...require("./core/render"),
+  AGGRED_DIR,
+  ErrorDigest,
+  PluginManager,
+  createErrorHtml,
+  createServerBase,
+  onError,
+  ...require("./plugins"),
+  ...require("./types/plugin"),
+  ...require("./types/render"),
   ...require("@modern-js/plugin"),
-  ...require("./core/loadPlugins"),
   ...require("./types/config")
 });