@modern-js/server-core 2.67.3 → 2.67.4

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

@@ -53,12 +53,16 @@ async function loadServerConfigOld(pwd, configFile) {
   const serverConfig = await requireConfig(serverConfigPath);
   return serverConfig;
 }
-async function loadServerRuntimeConfig(pwd, oldServerFile = import_utils.DEFAULT_SERVER_CONFIG, newServerConfigPath) {
+async function loadServerRuntimeConfig(pwd, oldServerFile = import_utils.DEFAULT_SERVER_CONFIG, newServerConfigPath, metaName) {
   const newServerConfig = newServerConfigPath && await loadServerConfigNew(newServerConfigPath);
   if (newServerConfig) {
     return newServerConfig;
   }
   const oldServerConfig = await loadServerConfigOld(pwd, oldServerFile);
+  if (oldServerConfig) {
+    const meta = (0, import_utils.getMeta)(metaName);
+    console.warn(`${import_utils.chalk.red("\n[Warning]")} ${import_utils.chalk.yellow.bold(`\`${oldServerFile}\``)} is no longer maintained. To extend the server, please migrate to ${import_utils.chalk.yellow.bold(`\`server/${meta}.server.ts\``)};`);
+  }
   return oldServerConfig;
 }
 function loadServerCliConfig(pwd, defaultConfig = {}) {

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

@@ -43,14 +43,26 @@ var import_polyfills = require("./polyfills");
 (0, import_install.installGlobals)();
 const createWebRequest = (req, res, body) => {
   const headerRecord = [];
-  const len = req.rawHeaders.length;
-  for (let i = 0; i < len; i += 2) {
-    const key = req.rawHeaders[i];
-    if (!key.startsWith(":")) {
-      headerRecord.push([
-        key,
-        req.rawHeaders[i + 1]
-      ]);
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (key.startsWith(":")) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0) {
+          headerRecord.push([
+            key,
+            item
+          ]);
+        }
+      }
+    } else if (value !== void 0) {
+      if (typeof value === "string") {
+        headerRecord.push([
+          key,
+          value
+        ]);
+      }
     }
   }
   const { method } = req;

package/dist/cjs/plugins/customServer/index.js

@@ -92,19 +92,14 @@ class CustomServer {
       }
     };
   }
-  async getServerMiddleware(renderMiddlewares) {
+  async getServerMiddleware() {
     const serverMiddleware = await this.serverMiddlewarePromise;
     if (!serverMiddleware || !(0, import_utils.isFunction)(serverMiddleware) && !(0, import_utils.isArray)(serverMiddleware)) {
-      return renderMiddlewares;
+      return;
     }
     if (Array.isArray(serverMiddleware)) {
       const unstableMiddlewares = getServerMidFromUnstableMid(serverMiddleware);
-      return [
-        ...renderMiddlewares || [],
-        ...unstableMiddlewares
-      ];
-    } else if (renderMiddlewares) {
-      return renderMiddlewares;
+      return unstableMiddlewares;
     }
     return async (c, next) => {
       var _c_env_node_res, _c_env_node, _c_env;
@@ -130,9 +125,8 @@ class CustomServer {
       }
     };
   }
-  constructor(hooks, serverBase, pwd) {
+  constructor(hooks, pwd) {
     this.hooks = hooks;
-    this.serverBase = serverBase;
     const webExtension = [];
     this.serverMiddlewarePromise = hooks.prepareWebServer.call({
       pwd,

package/dist/cjs/plugins/index.js

@@ -23,6 +23,7 @@ __export(plugins_exports, {
   faviconPlugin: () => import_favicon.faviconPlugin,
   getRenderHandler: () => import_render.getRenderHandler,
   handleSetupResult: () => import_compat.handleSetupResult,
+  injectConfigMiddlewarePlugin: () => import_middlewares.injectConfigMiddlewarePlugin,
   injectRenderHandlerPlugin: () => import_render.injectRenderHandlerPlugin,
   injectServerTiming: () => import_monitors.injectServerTiming,
   injectloggerPlugin: () => import_monitors.injectloggerPlugin,
@@ -38,6 +39,7 @@ var import_processedBy = require("./processedBy");
 var import_log = require("./log");
 var import_default = require("./default");
 var import_compat = require("./compat");
+var import_middlewares = require("./middlewares");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   compatPlugin,
@@ -45,6 +47,7 @@ var import_compat = require("./compat");
   faviconPlugin,
   getRenderHandler,
   handleSetupResult,
+  injectConfigMiddlewarePlugin,
   injectRenderHandlerPlugin,
   injectServerTiming,
   injectloggerPlugin,

package/dist/cjs/plugins/middlewares.js

@@ -0,0 +1,43 @@
+"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 middlewares_exports = {};
+__export(middlewares_exports, {
+  injectConfigMiddlewarePlugin: () => injectConfigMiddlewarePlugin
+});
+module.exports = __toCommonJS(middlewares_exports);
+const injectConfigMiddlewarePlugin = (configMiddlewares = [], configRenderMiddlewares = []) => ({
+  name: "@modern-js/plugin-inject-config-middleware",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares, renderMiddlewares } = api.useAppContext();
+        configMiddlewares.forEach((m) => {
+          middlewares.push(m);
+        });
+        configRenderMiddlewares.forEach((m) => {
+          renderMiddlewares.push(m);
+        });
+      }
+    };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  injectConfigMiddlewarePlugin
+});

package/dist/cjs/plugins/render/index.js

@@ -33,15 +33,13 @@ const renderPlugin = () => ({
   setup(api) {
     return {
       async prepare() {
-        var _config_render;
-        const { middlewares, routes, render, distDirectory: pwd, serverBase } = api.useAppContext();
+        const { middlewares, routes, render, distDirectory: pwd, renderMiddlewares } = api.useAppContext();
         const hooks = api.getHooks();
         const config = api.useConfigContext();
         if (!routes) {
           return;
         }
-        const customServer = new import_customServer.CustomServer(hooks, serverBase, pwd);
-        const serverMiddleware = ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.middleware) && (0, import_customServer.getServerMidFromUnstableMid)(config.render.middleware);
+        const customServer = new import_customServer.CustomServer(hooks, pwd);
         const pageRoutes = getPageRoutes(routes);
         middlewares.push({
           name: "page-latency",
@@ -59,7 +57,14 @@ const renderPlugin = () => ({
               handler: customServerHookMiddleware
             });
           }
-          const customServerMiddleware = await customServer.getServerMiddleware(serverMiddleware);
+          renderMiddlewares === null || renderMiddlewares === void 0 ? void 0 : renderMiddlewares.forEach((m) => {
+            middlewares.push({
+              name: m.name,
+              path: urlPath,
+              handler: m.handler
+            });
+          });
+          const customServerMiddleware = await customServer.getServerMiddleware();
           customServerMiddleware && middlewares.push({
             name: "custom-server-middleware",
             path: urlPath,

package/dist/cjs/plugins/render/inject.js

@@ -28,7 +28,6 @@ const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig }) => ({
   setup(api) {
     return {
       async prepare() {
-        var _config_render;
         const { distDirectory: pwd, routes, metaName } = api.useAppContext();
         const config = api.useConfigContext();
         const hookRunner = api.useHookRunners();
@@ -47,7 +46,8 @@ const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig }) => ({
           routes,
           config,
           metaName,
-          cacheConfig: ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.cache) || cacheConfig,
+          // TODO: support modern.server.ts cache config
+          cacheConfig,
           staticGenerate,
           onFallback
         };

package/dist/cjs/serverBase.js

@@ -42,7 +42,6 @@ class ServerBase {
       cliConfig,
       serverConfig: serverConfig || {}
     });
-    this.addPlugins(mergedConfig.plugins || []);
     const { serverContext } = await import_server.server.run({
       plugins: this.plugins,
       options: this.options,

package/dist/esm/adapters/node/helper/loadConfig.js

@@ -1,7 +1,7 @@
 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, DEFAULT_SERVER_CONFIG, OUTPUT_CONFIG_FILE, lodash as _, compatibleRequire, ensureAbsolutePath, requireExistModule } from "@modern-js/utils";
+import { fs, DEFAULT_SERVER_CONFIG, OUTPUT_CONFIG_FILE, lodash as _, chalk, compatibleRequire, ensureAbsolutePath, getMeta, requireExistModule } from "@modern-js/utils";
 import { parse } from "flatted";
 var requireConfig = function() {
   var _ref = _async_to_generator(function(serverConfigPath) {
@@ -82,12 +82,12 @@ function loadServerRuntimeConfig(pwd) {
 }
 function _loadServerRuntimeConfig() {
   _loadServerRuntimeConfig = _async_to_generator(function(pwd) {
-    var oldServerFile, newServerConfigPath, newServerConfig, _tmp, oldServerConfig;
+    var oldServerFile, newServerConfigPath, metaName, newServerConfig, _tmp, oldServerConfig, meta;
     var _arguments = arguments;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          oldServerFile = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : DEFAULT_SERVER_CONFIG, newServerConfigPath = _arguments.length > 2 ? _arguments[2] : void 0;
+          oldServerFile = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : DEFAULT_SERVER_CONFIG, newServerConfigPath = _arguments.length > 2 ? _arguments[2] : void 0, metaName = _arguments.length > 3 ? _arguments[3] : void 0;
           _tmp = newServerConfigPath;
           if (!_tmp)
             return [
@@ -115,6 +115,10 @@ function _loadServerRuntimeConfig() {
           ];
         case 3:
           oldServerConfig = _state.sent();
+          if (oldServerConfig) {
+            meta = getMeta(metaName);
+            console.warn("".concat(chalk.red("\n[Warning]"), " ").concat(chalk.yellow.bold("`".concat(oldServerFile, "`")), " is no longer maintained. To extend the server, please migrate to ").concat(chalk.yellow.bold("`server/".concat(meta, ".server.ts`")), ";"));
+          }
           return [
             2,
             oldServerConfig

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

@@ -12,14 +12,60 @@ import { writeReadableStreamToWritable as writeReadableStreamToWritable2 } from
 installGlobals();
 var createWebRequest = function(req, res, body) {
   var headerRecord = [];
-  var len = req.rawHeaders.length;
-  for (var i = 0; i < len; i += 2) {
-    var key = req.rawHeaders[i];
-    if (!key.startsWith(":")) {
-      headerRecord.push([
-        key,
-        req.rawHeaders[i + 1]
-      ]);
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = Object.entries(req.headers)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+      if (key.startsWith(":")) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+        try {
+          for (var _iterator1 = value[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+            var item = _step1.value;
+            if (item !== void 0) {
+              headerRecord.push([
+                key,
+                item
+              ]);
+            }
+          }
+        } catch (err) {
+          _didIteratorError1 = true;
+          _iteratorError1 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+              _iterator1.return();
+            }
+          } finally {
+            if (_didIteratorError1) {
+              throw _iteratorError1;
+            }
+          }
+        }
+      } else if (value !== void 0) {
+        if (typeof value === "string") {
+          headerRecord.push([
+            key,
+            value
+          ]);
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
     }
   }
   var method = req.method;

package/dist/esm/plugins/customServer/index.js

@@ -1,6 +1,5 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
-import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { time } from "@modern-js/runtime-utils/time";
 import { isArray, isFunction } from "@modern-js/utils";
@@ -17,10 +16,9 @@ var isHtmlResponse = function(response) {
 };
 var CustomServer = /* @__PURE__ */ function() {
   "use strict";
-  function CustomServer2(hooks, serverBase, pwd) {
+  function CustomServer2(hooks, pwd) {
     _class_call_check(this, CustomServer2);
     this.hooks = hooks;
-    this.serverBase = serverBase;
     var webExtension = [];
     this.serverMiddlewarePromise = hooks.prepareWebServer.call({
       pwd,
@@ -165,7 +163,7 @@ var CustomServer = /* @__PURE__ */ function() {
       };
     }();
   };
-  _proto.getServerMiddleware = function getServerMiddleware(renderMiddlewares) {
+  _proto.getServerMiddleware = function getServerMiddleware() {
     var _this = this;
     return _async_to_generator(function() {
       var serverMiddleware, unstableMiddlewares;
@@ -180,20 +178,14 @@ var CustomServer = /* @__PURE__ */ function() {
             serverMiddleware = _state.sent();
             if (!serverMiddleware || !isFunction(serverMiddleware) && !isArray(serverMiddleware)) {
               return [
-                2,
-                renderMiddlewares
+                2
               ];
             }
             if (Array.isArray(serverMiddleware)) {
               unstableMiddlewares = getServerMidFromUnstableMid(serverMiddleware);
               return [
                 2,
-                _to_consumable_array(renderMiddlewares || []).concat(_to_consumable_array(unstableMiddlewares))
-              ];
-            } else if (renderMiddlewares) {
-              return [
-                2,
-                renderMiddlewares
+                unstableMiddlewares
               ];
             }
             return [

package/dist/esm/plugins/index.js

@@ -5,12 +5,14 @@ import { processedByPlugin } from "./processedBy";
 import { logPlugin } from "./log";
 import { createDefaultPlugins } from "./default";
 import { compatPlugin, handleSetupResult } from "./compat";
+import { injectConfigMiddlewarePlugin } from "./middlewares";
 export {
   compatPlugin,
   createDefaultPlugins,
   faviconPlugin,
   getRenderHandler,
   handleSetupResult,
+  injectConfigMiddlewarePlugin,
   injectRenderHandlerPlugin,
   injectServerTiming,
   injectloggerPlugin,

package/dist/esm/plugins/middlewares.js

@@ -0,0 +1,22 @@
+var injectConfigMiddlewarePlugin = function() {
+  var configMiddlewares = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [], configRenderMiddlewares = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  return {
+    name: "@modern-js/plugin-inject-config-middleware",
+    setup: function setup(api) {
+      return {
+        prepare: function prepare() {
+          var _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, renderMiddlewares = _api_useAppContext.renderMiddlewares;
+          configMiddlewares.forEach(function(m) {
+            middlewares.push(m);
+          });
+          configRenderMiddlewares.forEach(function(m) {
+            renderMiddlewares.push(m);
+          });
+        }
+      };
+    }
+  };
+};
+export {
+  injectConfigMiddlewarePlugin
+};

package/dist/esm/plugins/render/index.js

@@ -1,9 +1,10 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { _ as _ts_values } from "@swc/helpers/_/_ts_values";
 import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
 import { getLoaderCtx } from "../../helper";
 import { sortRoutes } from "../../utils";
-import { CustomServer, getServerMidFromUnstableMid } from "../customServer";
+import { CustomServer } from "../customServer";
 import { requestLatencyMiddleware } from "../monitors";
 export * from "./inject";
 var renderPlugin = function() {
@@ -13,11 +14,11 @@ var renderPlugin = function() {
       return {
         prepare: function prepare() {
           return _async_to_generator(function() {
-            var _config_render, _api_useAppContext, middlewares, routes, render, pwd, serverBase, hooks, config, customServer, serverMiddleware, pageRoutes, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, _config_server, originUrlPath, _route_entryName, entryName, urlPath, customServerHookMiddleware, customServerMiddleware, err;
+            var _api_useAppContext, middlewares, routes, render, pwd, renderMiddlewares, hooks, config, customServer, pageRoutes, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err;
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
-                  _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, routes = _api_useAppContext.routes, render = _api_useAppContext.render, pwd = _api_useAppContext.distDirectory, serverBase = _api_useAppContext.serverBase;
+                  _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, routes = _api_useAppContext.routes, render = _api_useAppContext.render, pwd = _api_useAppContext.distDirectory, renderMiddlewares = _api_useAppContext.renderMiddlewares;
                   hooks = api.getHooks();
                   config = api.useConfigContext();
                   if (!routes) {
@@ -25,8 +26,7 @@ var renderPlugin = function() {
                       2
                     ];
                   }
-                  customServer = new CustomServer(hooks, serverBase, pwd);
-                  serverMiddleware = ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.middleware) && getServerMidFromUnstableMid(config.render.middleware);
+                  customServer = new CustomServer(hooks, pwd);
                   pageRoutes = getPageRoutes(routes);
                   middlewares.push({
                     name: "page-latency",
@@ -41,6 +41,51 @@ var renderPlugin = function() {
                     7,
                     8
                   ]);
+                  _loop = function() {
+                    var route, _config_server, originUrlPath, _route_entryName, entryName, urlPath, customServerHookMiddleware, customServerMiddleware;
+                    return _ts_generator(this, function(_state2) {
+                      switch (_state2.label) {
+                        case 0:
+                          route = _step.value;
+                          originUrlPath = route.urlPath, _route_entryName = route.entryName, entryName = _route_entryName === void 0 ? MAIN_ENTRY_NAME : _route_entryName;
+                          urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
+                          if (((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.disableHook) !== true) {
+                            customServerHookMiddleware = customServer.getHookMiddleware(entryName, routes);
+                            middlewares.push({
+                              name: "custom-server-hook",
+                              path: urlPath,
+                              handler: customServerHookMiddleware
+                            });
+                          }
+                          renderMiddlewares === null || renderMiddlewares === void 0 ? void 0 : renderMiddlewares.forEach(function(m) {
+                            middlewares.push({
+                              name: m.name,
+                              path: urlPath,
+                              handler: m.handler
+                            });
+                          });
+                          return [
+                            4,
+                            customServer.getServerMiddleware()
+                          ];
+                        case 1:
+                          customServerMiddleware = _state2.sent();
+                          customServerMiddleware && middlewares.push({
+                            name: "custom-server-middleware",
+                            path: urlPath,
+                            handler: customServerMiddleware
+                          });
+                          render && middlewares.push({
+                            name: "render",
+                            path: urlPath,
+                            handler: createRenderHandler(render)
+                          });
+                          return [
+                            2
+                          ];
+                      }
+                    });
+                  };
                   _iterator = pageRoutes[Symbol.iterator]();
                   _state.label = 2;
                 case 2:
@@ -49,33 +94,12 @@ var renderPlugin = function() {
                       3,
                       5
                     ];
-                  route = _step.value;
-                  originUrlPath = route.urlPath, _route_entryName = route.entryName, entryName = _route_entryName === void 0 ? MAIN_ENTRY_NAME : _route_entryName;
-                  urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
-                  if (((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.disableHook) !== true) {
-                    customServerHookMiddleware = customServer.getHookMiddleware(entryName, routes);
-                    middlewares.push({
-                      name: "custom-server-hook",
-                      path: urlPath,
-                      handler: customServerHookMiddleware
-                    });
-                  }
                   return [
-                    4,
-                    customServer.getServerMiddleware(serverMiddleware)
+                    5,
+                    _ts_values(_loop())
                   ];
                 case 3:
-                  customServerMiddleware = _state.sent();
-                  customServerMiddleware && middlewares.push({
-                    name: "custom-server-middleware",
-                    path: urlPath,
-                    handler: customServerMiddleware
-                  });
-                  render && middlewares.push({
-                    name: "render",
-                    path: urlPath,
-                    handler: createRenderHandler(render)
-                  });
+                  _state.sent();
                   _state.label = 4;
                 case 4:
                   _iteratorNormalCompletion = true;

package/dist/esm/plugins/render/inject.js

@@ -12,7 +12,7 @@ var injectRenderHandlerPlugin = function(param) {
       return {
         prepare: function prepare() {
           return _async_to_generator(function() {
-            var _config_render, _api_useAppContext, pwd, routes, metaName, config, hookRunner, onFallback, getRenderHandlerOptions, render;
+            var _api_useAppContext, pwd, routes, metaName, config, hookRunner, onFallback, getRenderHandlerOptions, render;
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
@@ -54,7 +54,8 @@ var injectRenderHandlerPlugin = function(param) {
                     routes,
                     config,
                     metaName,
-                    cacheConfig: ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.cache) || cacheConfig,
+                    // TODO: support modern.server.ts cache config
+                    cacheConfig,
                     staticGenerate,
                     onFallback
                   };

package/dist/esm/serverBase.js

@@ -35,7 +35,6 @@ var ServerBase = /* @__PURE__ */ function() {
               cliConfig,
               serverConfig: serverConfig || {}
             });
-            _this.addPlugins(mergedConfig.plugins || []);
             return [
               4,
               server.run({

package/dist/esm-node/adapters/node/helper/loadConfig.js

@@ -1,5 +1,5 @@
 import path from "path";
-import { fs, DEFAULT_SERVER_CONFIG, OUTPUT_CONFIG_FILE, lodash as _, compatibleRequire, ensureAbsolutePath, requireExistModule } from "@modern-js/utils";
+import { fs, DEFAULT_SERVER_CONFIG, OUTPUT_CONFIG_FILE, lodash as _, chalk, compatibleRequire, ensureAbsolutePath, getMeta, requireExistModule } from "@modern-js/utils";
 import { parse } from "flatted";
 const requireConfig = async (serverConfigPath) => {
   if (fs.pathExistsSync(serverConfigPath)) {
@@ -19,12 +19,16 @@ async function loadServerConfigOld(pwd, configFile) {
   const serverConfig = await requireConfig(serverConfigPath);
   return serverConfig;
 }
-async function loadServerRuntimeConfig(pwd, oldServerFile = DEFAULT_SERVER_CONFIG, newServerConfigPath) {
+async function loadServerRuntimeConfig(pwd, oldServerFile = DEFAULT_SERVER_CONFIG, newServerConfigPath, metaName) {
   const newServerConfig = newServerConfigPath && await loadServerConfigNew(newServerConfigPath);
   if (newServerConfig) {
     return newServerConfig;
   }
   const oldServerConfig = await loadServerConfigOld(pwd, oldServerFile);
+  if (oldServerConfig) {
+    const meta = getMeta(metaName);
+    console.warn(`${chalk.red("\n[Warning]")} ${chalk.yellow.bold(`\`${oldServerFile}\``)} is no longer maintained. To extend the server, please migrate to ${chalk.yellow.bold(`\`server/${meta}.server.ts\``)};`);
+  }
   return oldServerConfig;
 }
 function loadServerCliConfig(pwd, defaultConfig = {}) {

package/dist/esm-node/adapters/node/node.js

@@ -7,14 +7,26 @@ import { writeReadableStreamToWritable as writeReadableStreamToWritable2 } from
 installGlobals();
 const createWebRequest = (req, res, body) => {
   const headerRecord = [];
-  const len = req.rawHeaders.length;
-  for (let i = 0; i < len; i += 2) {
-    const key = req.rawHeaders[i];
-    if (!key.startsWith(":")) {
-      headerRecord.push([
-        key,
-        req.rawHeaders[i + 1]
-      ]);
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (key.startsWith(":")) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0) {
+          headerRecord.push([
+            key,
+            item
+          ]);
+        }
+      }
+    } else if (value !== void 0) {
+      if (typeof value === "string") {
+        headerRecord.push([
+          key,
+          value
+        ]);
+      }
     }
   }
   const { method } = req;

package/dist/esm-node/plugins/customServer/index.js

@@ -68,19 +68,14 @@ class CustomServer {
       }
     };
   }
-  async getServerMiddleware(renderMiddlewares) {
+  async getServerMiddleware() {
     const serverMiddleware = await this.serverMiddlewarePromise;
     if (!serverMiddleware || !isFunction(serverMiddleware) && !isArray(serverMiddleware)) {
-      return renderMiddlewares;
+      return;
     }
     if (Array.isArray(serverMiddleware)) {
       const unstableMiddlewares = getServerMidFromUnstableMid(serverMiddleware);
-      return [
-        ...renderMiddlewares || [],
-        ...unstableMiddlewares
-      ];
-    } else if (renderMiddlewares) {
-      return renderMiddlewares;
+      return unstableMiddlewares;
     }
     return async (c, next) => {
       var _c_env_node_res, _c_env_node, _c_env;
@@ -106,9 +101,8 @@ class CustomServer {
       }
     };
   }
-  constructor(hooks, serverBase, pwd) {
+  constructor(hooks, pwd) {
     this.hooks = hooks;
-    this.serverBase = serverBase;
     const webExtension = [];
     this.serverMiddlewarePromise = hooks.prepareWebServer.call({
       pwd,

package/dist/esm-node/plugins/index.js

@@ -5,12 +5,14 @@ import { processedByPlugin } from "./processedBy";
 import { logPlugin } from "./log";
 import { createDefaultPlugins } from "./default";
 import { compatPlugin, handleSetupResult } from "./compat";
+import { injectConfigMiddlewarePlugin } from "./middlewares";
 export {
   compatPlugin,
   createDefaultPlugins,
   faviconPlugin,
   getRenderHandler,
   handleSetupResult,
+  injectConfigMiddlewarePlugin,
   injectRenderHandlerPlugin,
   injectServerTiming,
   injectloggerPlugin,

package/dist/esm-node/plugins/middlewares.js

@@ -0,0 +1,19 @@
+const injectConfigMiddlewarePlugin = (configMiddlewares = [], configRenderMiddlewares = []) => ({
+  name: "@modern-js/plugin-inject-config-middleware",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares, renderMiddlewares } = api.useAppContext();
+        configMiddlewares.forEach((m) => {
+          middlewares.push(m);
+        });
+        configRenderMiddlewares.forEach((m) => {
+          renderMiddlewares.push(m);
+        });
+      }
+    };
+  }
+});
+export {
+  injectConfigMiddlewarePlugin
+};

package/dist/esm-node/plugins/render/index.js

@@ -1,7 +1,7 @@
 import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
 import { getLoaderCtx } from "../../helper";
 import { sortRoutes } from "../../utils";
-import { CustomServer, getServerMidFromUnstableMid } from "../customServer";
+import { CustomServer } from "../customServer";
 import { requestLatencyMiddleware } from "../monitors";
 export * from "./inject";
 const renderPlugin = () => ({
@@ -9,15 +9,13 @@ const renderPlugin = () => ({
   setup(api) {
     return {
       async prepare() {
-        var _config_render;
-        const { middlewares, routes, render, distDirectory: pwd, serverBase } = api.useAppContext();
+        const { middlewares, routes, render, distDirectory: pwd, renderMiddlewares } = api.useAppContext();
         const hooks = api.getHooks();
         const config = api.useConfigContext();
         if (!routes) {
           return;
         }
-        const customServer = new CustomServer(hooks, serverBase, pwd);
-        const serverMiddleware = ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.middleware) && getServerMidFromUnstableMid(config.render.middleware);
+        const customServer = new CustomServer(hooks, pwd);
         const pageRoutes = getPageRoutes(routes);
         middlewares.push({
           name: "page-latency",
@@ -35,7 +33,14 @@ const renderPlugin = () => ({
               handler: customServerHookMiddleware
             });
           }
-          const customServerMiddleware = await customServer.getServerMiddleware(serverMiddleware);
+          renderMiddlewares === null || renderMiddlewares === void 0 ? void 0 : renderMiddlewares.forEach((m) => {
+            middlewares.push({
+              name: m.name,
+              path: urlPath,
+              handler: m.handler
+            });
+          });
+          const customServerMiddleware = await customServer.getServerMiddleware();
           customServerMiddleware && middlewares.push({
             name: "custom-server-middleware",
             path: urlPath,

package/dist/esm-node/plugins/render/inject.js

@@ -4,7 +4,6 @@ const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig }) => ({
   setup(api) {
     return {
       async prepare() {
-        var _config_render;
         const { distDirectory: pwd, routes, metaName } = api.useAppContext();
         const config = api.useConfigContext();
         const hookRunner = api.useHookRunners();
@@ -23,7 +22,8 @@ const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig }) => ({
           routes,
           config,
           metaName,
-          cacheConfig: ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.cache) || cacheConfig,
+          // TODO: support modern.server.ts cache config
+          cacheConfig,
           staticGenerate,
           onFallback
         };

package/dist/esm-node/serverBase.js

@@ -18,7 +18,6 @@ class ServerBase {
       cliConfig,
       serverConfig: serverConfig || {}
     });
-    this.addPlugins(mergedConfig.plugins || []);
     const { serverContext } = await server.run({
       plugins: this.plugins,
       options: this.options,

package/dist/types/adapters/node/helper/loadConfig.d.ts

@@ -1,3 +1,3 @@
 import type { CliConfig, ServerConfig, UserConfig } from '../../../types';
-export declare function loadServerRuntimeConfig(pwd: string, oldServerFile?: string, newServerConfigPath?: string): Promise<ServerConfig | undefined>;
+export declare function loadServerRuntimeConfig(pwd: string, oldServerFile?: string, newServerConfigPath?: string, metaName?: string): Promise<ServerConfig | undefined>;
 export declare function loadServerCliConfig(pwd: string, defaultConfig?: UserConfig): CliConfig;

package/dist/types/index.d.ts

@@ -3,8 +3,8 @@ export { AGGRED_DIR } from './constants';
 export type { ServerBase, ServerBaseOptions } from './serverBase';
 export { createServerBase } from './serverBase';
 export { useHonoContext } from './context';
-export { Hono, type MiddlewareHandler } from 'hono';
-export type { Middleware, Context, Next, HonoRequest as InternalRequest, ServerEnv, ServerManifest, ServerLoaderBundle, } from './types';
+export { Hono } from 'hono';
+export type { Middleware, MiddlewareHandler, Context, Next, HonoRequest as InternalRequest, ServerEnv, ServerManifest, ServerLoaderBundle, } from './types';
 export { getLoaderCtx } from './helper';
 export * from './plugins';
 export * from './types/plugins';

package/dist/types/plugins/customServer/index.d.ts

@@ -1,13 +1,11 @@
 import type { ServerRoute, UnstableMiddleware } from '@modern-js/types';
 import type { ServerNodeEnv } from '../../adapters/node/hono';
-import type { ServerBase } from '../../serverBase';
 import type { Middleware, ServerEnv, ServerPluginHooks } from '../../types';
 export declare class CustomServer {
     private hooks;
     private serverMiddlewarePromise;
-    private serverBase;
-    constructor(hooks: ServerPluginHooks, serverBase: ServerBase, pwd: string);
+    constructor(hooks: ServerPluginHooks, pwd: string);
     getHookMiddleware(entryName: string, routes: ServerRoute[]): Middleware<ServerEnv>;
-    getServerMiddleware(renderMiddlewares?: Middleware<ServerNodeEnv & ServerEnv>[]): Promise<Middleware<ServerNodeEnv & ServerEnv> | Array<Middleware<ServerNodeEnv & ServerEnv>> | undefined>;
+    getServerMiddleware(): Promise<Middleware<ServerNodeEnv & ServerEnv> | Array<Middleware<ServerNodeEnv & ServerEnv>> | undefined>;
 }
 export declare function getServerMidFromUnstableMid(serverMiddleware: UnstableMiddleware[]): Array<Middleware<ServerNodeEnv & ServerEnv>>;

package/dist/types/plugins/index.d.ts

@@ -5,3 +5,4 @@ export { processedByPlugin } from './processedBy';
 export { logPlugin } from './log';
 export { createDefaultPlugins, type CreateDefaultPluginsOptions, } from './default';
 export { compatPlugin, handleSetupResult } from './compat';
+export { injectConfigMiddlewarePlugin } from './middlewares';

package/dist/types/plugins/middlewares.d.ts

@@ -0,0 +1,2 @@
+import type { MiddlewareObj, ServerPluginLegacy } from '../types';
+export declare const injectConfigMiddlewarePlugin: (configMiddlewares?: MiddlewareObj[], configRenderMiddlewares?: MiddlewareObj[]) => ServerPluginLegacy;

package/dist/types/types/plugins/base.d.ts

@@ -1,6 +1,6 @@
 import type { Server as NodeServer } from 'http';
 import type { Http2SecureServer } from 'node:http2';
-import type { CacheOption, Container, HttpMethodDecider, Logger, Metrics, MiddlewareContext, Reporter, ServerRoute, UnstableMiddleware } from '@modern-js/types';
+import type { CacheOption, Container, HttpMethodDecider, Logger, Metrics, MiddlewareContext, Reporter, ServerRoute } from '@modern-js/types';
 import type { MiddlewareHandler } from 'hono';
 import type { UserConfig } from '../config';
 import type { Render } from '../render';
@@ -36,15 +36,15 @@ export type WebServerStartInput = {
 export type WebAdapter = (ctx: MiddlewareContext) => void | Promise<void>;
 /** Plugin Api */
 type MiddlewareOrder = 'pre' | 'post' | 'default';
-export type Middleware = {
+export type MiddlewareObj = {
     name: string;
     path?: string;
     method?: 'options' | 'get' | 'post' | 'put' | 'delete' | 'patch' | 'all';
     handler: MiddlewareHandler | MiddlewareHandler[];
-    before?: Array<Middleware['name']>;
+    before?: Array<MiddlewareObj['name']>;
     order?: MiddlewareOrder;
 };
-export type ServerMiddleware = Middleware;
+export type ServerMiddleware = MiddlewareObj;
 export interface GetRenderHandlerOptions {
     pwd: string;
     routes: ServerRoute[];
@@ -56,7 +56,8 @@ export interface GetRenderHandlerOptions {
 }
 declare module '@modern-js/types' {
     interface ISAppContext {
-        middlewares: Middleware[];
+        renderMiddlewares: MiddlewareObj[];
+        middlewares: MiddlewareObj[];
         metaName: string;
         getRenderOptions?: GetRenderHandlerOptions;
         render?: Render;
@@ -68,12 +69,8 @@ export type CacheConfig = {
     strategy: CacheOption;
     container?: Container;
 };
-type RenderMiddleware = UnstableMiddleware;
-export interface RenderConfig {
-    cache?: CacheConfig;
-    middleware?: RenderMiddleware[];
-}
 export type ServerConfig = {
-    render?: RenderConfig;
+    renderMiddlewares?: MiddlewareObj[];
+    middlewares?: MiddlewareObj[];
     plugins?: (ServerPlugin | ServerPluginLegacy)[];
 } & UserConfig;

package/dist/types/types/plugins/index.d.ts

@@ -1,3 +1,3 @@
 export * from './new';
 export * from './old';
-export type { ServerConfig, CacheConfig, OnFallback, FallbackReason, GetRenderHandlerOptions, FileChangeEvent, FallbackInput, WebServerStartInput, APIServerStartInput, ServerMiddleware, } from './base';
+export type { ServerConfig, CacheConfig, OnFallback, FallbackReason, GetRenderHandlerOptions, FileChangeEvent, FallbackInput, WebServerStartInput, APIServerStartInput, ServerMiddleware, MiddlewareObj, } from './base';

package/dist/types/types/plugins/new.d.ts

@@ -2,7 +2,7 @@ import type { AsyncHook, AsyncPipelineHook, ServerContext as BaseServerContext,
 import type { Hooks } from '@modern-js/plugin-v2/server';
 import type { AfterMatchContext, AfterRenderContext, AfterStreamingRenderContext, ISAppContext, UnstableMiddleware } from '@modern-js/types';
 import type { MiddlewareHandler } from 'hono';
-import type { Middleware } from './base';
+import type { MiddlewareObj } from './base';
 import type { APIServerStartInput, FallbackInput, ServerConfig, WebAdapter, WebServerStartInput } from './base';
 export type FallbackFn = (input: FallbackInput) => Promise<FallbackInput>;
 export type PrepareWebServerFn = (input: WebServerStartInput) => Promise<WebAdapter | Array<UnstableMiddleware> | null>;
@@ -13,7 +13,7 @@ export type AfterStreamingRenderContextFn = (ctx: AfterStreamingRenderContext) =
 export interface ServerPluginExtends extends BaseServerPluginExtends {
     config: ServerConfig;
     extendContext: {
-        middlewares: Middleware[];
+        middlewares: MiddlewareObj[];
     };
     extendApi: {
         setAppContext: (c: ISAppContext) => void;

package/dist/types/types/server.d.ts

@@ -63,4 +63,4 @@ type ServerVariables = {
 export type ServerEnv = {
     Variables: ServerVariables;
 };
-export type { Context, Env, HonoRequest, Next, MiddlewareHandler as Middleware, } from 'hono';
+export type { Context, Env, HonoRequest, Next, MiddlewareHandler, MiddlewareHandler as Middleware, } from 'hono';

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.67.3",
+  "version": "2.67.4",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -54,10 +54,10 @@
     "flatted": "^3.2.9",
     "hono": "^3.12.2",
     "ts-deepmerge": "7.0.2",
-    "@modern-js/plugin": "2.67.3",
-    "@modern-js/plugin-v2": "2.67.3",
-    "@modern-js/runtime-utils": "2.67.3",
-    "@modern-js/utils": "2.67.3"
+    "@modern-js/plugin": "2.67.4",
+    "@modern-js/plugin-v2": "2.67.4",
+    "@modern-js/runtime-utils": "2.67.4",
+    "@modern-js/utils": "2.67.4"
   },
   "devDependencies": {
     "@types/cloneable-readable": "^2.0.3",
@@ -68,9 +68,9 @@
     "jest": "^29",
     "ts-jest": "^29.1.0",
     "typescript": "^5",
-    "@modern-js/types": "2.67.3",
-    "@scripts/jest-config": "2.66.0",
-    "@scripts/build": "2.66.0"
+    "@modern-js/types": "2.67.4",
+    "@scripts/build": "2.66.0",
+    "@scripts/jest-config": "2.66.0"
   },
   "sideEffects": false,
   "publishConfig": {