@modern-js/server 2.56.0 → 2.56.2

package/dist/cjs/createDevServer.js

@@ -36,7 +36,7 @@ var import_server_core = require("@modern-js/server-core");
 var import_node = require("@modern-js/server-core/node");
 var import_helpers = require("./helpers");
 var import_dev = require("./dev");
-const createDevServer = async (options, applyPlugins) => {
+async function createDevServer(options, applyPlugins) {
   const { config, pwd, serverConfigFile, serverConfigPath } = options;
   const dev = (0, import_helpers.getDevOptions)(options);
   const distDir = import_node_path.default.resolve(pwd, config.output.path || "dist");
@@ -63,8 +63,16 @@ const createDevServer = async (options, applyPlugins) => {
   ]);
   await applyPlugins(server, prodServerOptions, nodeServer);
   await server.init();
+  nodeServer.listen({
+    host: dev.host || "127.0.0.1",
+    port: dev.port || "8080"
+  }, (err) => {
+    if (err) {
+      throw err;
+    }
+  });
   return nodeServer;
-};
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createDevServer

package/dist/cjs/dev.js

@@ -27,17 +27,21 @@ var import_helpers = require("./helpers");
 const devPlugin = (options) => ({
   name: "@modern-js/plugin-dev",
   setup(api) {
-    const { getMiddlewares, rsbuild, config, pwd } = options;
+    const { config, pwd, builder } = options;
     const closeCb = [];
-    const { middlewares: rsbuildMiddlewares, close, onHTTPUpgrade } = (getMiddlewares === null || getMiddlewares === void 0 ? void 0 : getMiddlewares()) || {};
-    close && closeCb.push(close);
     const dev = (0, import_helpers.getDevOptions)(options);
     return {
       async prepare() {
+        var _dev_after, _dev_before;
+        const builderDevServer = await (builder === null || builder === void 0 ? void 0 : builder.createDevServer({
+          runCompile: options.runCompile
+        }));
+        const { middlewares: builderMiddlewares, close, onHTTPUpgrade } = builderDevServer || {};
+        close && closeCb.push(close);
         const { middlewares, distDirectory, nodeServer, apiDirectory, sharedDirectory, serverBase } = api.useAppContext();
         onHTTPUpgrade && (nodeServer === null || nodeServer === void 0 ? void 0 : nodeServer.on("upgrade", onHTTPUpgrade));
         const runner = api.useHookRunners();
-        rsbuild === null || rsbuild === void 0 ? void 0 : rsbuild.onDevCompileDone(({ stats }) => {
+        builder === null || builder === void 0 ? void 0 : builder.onDevCompileDone(({ stats }) => {
           if (stats.toJson({
             all: false
           }).name !== "server") {
@@ -61,16 +65,45 @@ const devPlugin = (options) => ({
             cb();
           });
         }));
-        await (0, import_helpers.registerMockHandlers)({
-          pwd,
-          server: serverBase
+        const before = [];
+        const after = [];
+        const { setupMiddlewares = [] } = dev;
+        if (((_dev_after = dev.after) === null || _dev_after === void 0 ? void 0 : _dev_after.length) || ((_dev_before = dev.before) === null || _dev_before === void 0 ? void 0 : _dev_before.length)) {
+          setupMiddlewares.push((middlewares2) => {
+            middlewares2.unshift(...dev.before || []);
+            middlewares2.push(...dev.after || []);
+          });
+        }
+        setupMiddlewares.forEach((handler) => {
+          handler({
+            unshift: (...handlers) => before.unshift(...handlers),
+            push: (...handlers) => after.push(...handlers)
+          }, {
+            sockWrite: () => {
+            }
+          });
         });
-        if (rsbuildMiddlewares) {
+        before.forEach((middleware, index) => {
           middlewares.push({
-            name: "rsbuild-dev",
-            handler: (0, import_node.connectMid2HonoMid)(rsbuildMiddlewares)
+            name: `before-dev-server-${index}`,
+            handler: (0, import_node.connectMid2HonoMid)(middleware)
           });
-        }
+        });
+        const mockMiddleware = await (0, import_helpers.getMockMiddleware)(pwd);
+        middlewares.push({
+          name: "mock-dev",
+          handler: mockMiddleware
+        });
+        builderMiddlewares && middlewares.push({
+          name: "rsbuild-dev",
+          handler: (0, import_node.connectMid2HonoMid)(builderMiddlewares)
+        });
+        after.forEach((middleware, index) => {
+          middlewares.push({
+            name: `after-dev-server-${index}`,
+            handler: (0, import_node.connectMid2HonoMid)(middleware)
+          });
+        });
         middlewares.push({
           name: "init-file-reader",
           handler: (0, import_helpers.initFileReader)()

package/dist/cjs/helpers/index.js

@@ -47,11 +47,8 @@ async function onServerChange({ pwd, filepath, event, server }) {
   const mockPath = import_path.default.normalize(import_path.default.join(pwd, mock));
   const { runner } = server;
   if (filepath.startsWith(mockPath)) {
-    await (0, import_mock.registerMockHandlers)({
-      pwd,
-      server
-    });
-    import_utils.logger.info("Finish registering the mock handlers");
+    await (0, import_mock.initOrUpdateMockMiddlewares)(pwd);
+    import_utils.logger.info("Finish update the mock handlers");
   } else {
     try {
       const fileChangeEvent = {

package/dist/cjs/helpers/mock.js

@@ -28,13 +28,18 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var mock_exports = {};
 __export(mock_exports, {
-  registerMockHandlers: () => registerMockHandlers
+  getMatched: () => getMatched,
+  getMockMiddleware: () => getMockMiddleware,
+  initOrUpdateMockMiddlewares: () => initOrUpdateMockMiddlewares
 });
 module.exports = __toCommonJS(mock_exports);
 var import_node_path = __toESM(require("node:path"));
 var import_utils = require("@modern-js/utils");
 var import_server_core = require("@modern-js/server-core");
 var import_node = require("@modern-js/server-core/node");
+var import_path_to_regexp = require("path-to-regexp");
+let mockAPIs = [];
+let mockConfig;
 const parseKey = (key) => {
   const _blank = " ";
   const splitted = key.split(_blank).filter(Boolean);
@@ -50,8 +55,7 @@ const parseKey = (key) => {
     path: key
   };
 };
-const mockHandlerRegistry = /* @__PURE__ */ new Map();
-const registerMockHandlers = async ({ pwd, server }) => {
+const getMockModule = async (pwd) => {
   const exts = [
     ".ts",
     ".js"
@@ -65,54 +69,72 @@ const registerMockHandlers = async ({ pwd, server }) => {
     }
   }
   if (!mockFilePath) {
-    return null;
+    return void 0;
   }
-  const { default: mockModule, config } = await Promise.resolve().then(() => __toESM(require(mockFilePath)));
+  const { default: mockHandlers, config } = await Promise.resolve().then(() => __toESM(require(mockFilePath)));
   const enable = config === null || config === void 0 ? void 0 : config.enable;
   if (enable === false) {
-    return;
+    return void 0;
   }
-  if (!mockModule) {
+  if (!mockHandlers) {
     throw new Error(`Mock file ${mockFilePath} parsed failed!`);
   }
-  Object.entries(mockModule).forEach(([key, handler]) => {
+  return {
+    mockHandlers,
+    config
+  };
+};
+const getMatched = (request, mockApis) => {
+  const { path: targetPathname, method: targetMethod } = request;
+  const matched = mockApis.find((mockApi) => {
+    const { method, path: pathname } = mockApi;
+    if (method.toLowerCase() === targetMethod.toLowerCase()) {
+      return (0, import_path_to_regexp.match)(pathname, {
+        encode: encodeURI,
+        decode: decodeURIComponent
+      })(targetPathname);
+    }
+    return false;
+  });
+  return matched;
+};
+async function initOrUpdateMockMiddlewares(pwd) {
+  const mockModule = await getMockModule(pwd);
+  mockConfig = mockModule === null || mockModule === void 0 ? void 0 : mockModule.config;
+  mockAPIs = Object.entries((mockModule === null || mockModule === void 0 ? void 0 : mockModule.mockHandlers) || {}).map(([key, handler]) => {
     const { method, path: path2 } = parseKey(key);
-    const methodName = method.toLowerCase();
-    const handlerId = `${methodName}-${path2}`;
-    const mockInfo = mockHandlerRegistry.get(handlerId);
-    if (mockInfo) {
-      mockInfo.handler = handler;
-    } else {
-      mockHandlerRegistry.set(handlerId, {
-        handler,
-        isRegistered: false
-      });
+    return {
+      method,
+      path: path2,
+      handler
+    };
+  });
+}
+async function getMockMiddleware(pwd) {
+  await initOrUpdateMockMiddlewares(pwd);
+  const mockMiddleware = async (c, next) => {
+    if (typeof (mockConfig === null || mockConfig === void 0 ? void 0 : mockConfig.enable) === "function") {
+      const isEnabled = mockConfig.enable(c.env.node.req, c.env.node.res);
+      if (!isEnabled) {
+        return next();
+      }
     }
-    if (typeof server[methodName] === "function") {
-      const mockHandler = async (c, next) => {
-        var _mockHandlerRegistry_get;
-        if (typeof enable === "function") {
-          const isEnabled = enable(c.env.node.req, c.env.node.res);
-          if (!isEnabled) {
-            return next();
-          }
-        }
-        const handler2 = (_mockHandlerRegistry_get = mockHandlerRegistry.get(handlerId)) === null || _mockHandlerRegistry_get === void 0 ? void 0 : _mockHandlerRegistry_get.handler;
-        if (typeof handler2 === "function") {
-          await (0, import_node.connectMid2HonoMid)(handler2)(c, next);
-        } else {
-          return c.json(handler2);
-        }
-      };
-      const handlerInfo = mockHandlerRegistry.get(handlerId);
-      if (handlerInfo && !(handlerInfo === null || handlerInfo === void 0 ? void 0 : handlerInfo.isRegistered)) {
-        server[methodName](path2, mockHandler);
-        handlerInfo.isRegistered = true;
+    const matchedMockAPI = getMatched(c.req, mockAPIs);
+    if (matchedMockAPI) {
+      const { handler } = matchedMockAPI;
+      if (typeof handler === "function") {
+        return await (0, import_node.connectMid2HonoMid)(handler)(c, next);
+      } else {
+        return c.json(handler);
       }
     }
-  });
-};
+    return next();
+  };
+  return mockMiddleware;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  registerMockHandlers
+  getMatched,
+  getMockMiddleware,
+  initOrUpdateMockMiddlewares
 });

package/dist/esm/createDevServer.js

@@ -7,8 +7,11 @@ import { createServerBase } from "@modern-js/server-core";
 import { createNodeServer, loadServerRuntimeConfig } from "@modern-js/server-core/node";
 import { getDevOptions } from "./helpers";
 import { devPlugin } from "./dev";
-var createDevServer = function() {
-  var _ref = _async_to_generator(function(options, applyPlugins) {
+function createDevServer(options, applyPlugins) {
+  return _createDevServer.apply(this, arguments);
+}
+function _createDevServer() {
+  _createDevServer = _async_to_generator(function(options, applyPlugins) {
     var config, pwd, serverConfigFile, serverConfigPath, dev, distDir, serverConfig, prodServerOptions, server, devHttpsOption, nodeServer, genHttpsOptions, httpsOptions;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
@@ -76,6 +79,14 @@ var createDevServer = function() {
           ];
         case 8:
           _state.sent();
+          nodeServer.listen({
+            host: dev.host || "127.0.0.1",
+            port: dev.port || "8080"
+          }, function(err) {
+            if (err) {
+              throw err;
+            }
+          });
           return [
             2,
             nodeServer
@@ -83,10 +94,8 @@ var createDevServer = function() {
       }
     });
   });
-  return function createDevServer2(options, applyPlugins) {
-    return _ref.apply(this, arguments);
-  };
-}();
+  return _createDevServer.apply(this, arguments);
+}
 export {
   createDevServer
 };

package/dist/esm/dev.js

@@ -1,28 +1,37 @@
 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 { connectMid2HonoMid } from "@modern-js/server-core/node";
 import { API_DIR, SHARED_DIR } from "@modern-js/utils";
-import { startWatcher, onRepack, getDevOptions, initFileReader, registerMockHandlers } from "./helpers";
+import { startWatcher, onRepack, getDevOptions, initFileReader, getMockMiddleware } from "./helpers";
 var devPlugin = function(options) {
   return {
     name: "@modern-js/plugin-dev",
     setup: function setup(api) {
-      var getMiddlewares = options.getMiddlewares, rsbuild = options.rsbuild, config = options.config, pwd = options.pwd;
+      var config = options.config, pwd = options.pwd, builder = options.builder;
       var closeCb = [];
-      var _ref = (getMiddlewares === null || getMiddlewares === void 0 ? void 0 : getMiddlewares()) || {}, rsbuildMiddlewares = _ref.middlewares, close = _ref.close, onHTTPUpgrade = _ref.onHTTPUpgrade;
-      close && closeCb.push(close);
       var dev = getDevOptions(options);
       return {
         prepare: function prepare() {
           return _async_to_generator(function() {
-            var _api_useAppContext, middlewares, distDirectory, nodeServer, apiDirectory, sharedDirectory, serverBase, runner, watchOptions, watcher;
+            var _dev_after, _dev_before, builderDevServer, _ref, builderMiddlewares, close, onHTTPUpgrade, _api_useAppContext, middlewares, distDirectory, nodeServer, apiDirectory, sharedDirectory, serverBase, runner, watchOptions, watcher, before, after, _dev_setupMiddlewares, setupMiddlewares, mockMiddleware;
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
+                  return [
+                    4,
+                    builder === null || builder === void 0 ? void 0 : builder.createDevServer({
+                      runCompile: options.runCompile
+                    })
+                  ];
+                case 1:
+                  builderDevServer = _state.sent();
+                  _ref = builderDevServer || {}, builderMiddlewares = _ref.middlewares, close = _ref.close, onHTTPUpgrade = _ref.onHTTPUpgrade;
+                  close && closeCb.push(close);
                   _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, distDirectory = _api_useAppContext.distDirectory, nodeServer = _api_useAppContext.nodeServer, apiDirectory = _api_useAppContext.apiDirectory, sharedDirectory = _api_useAppContext.sharedDirectory, serverBase = _api_useAppContext.serverBase;
                   onHTTPUpgrade && (nodeServer === null || nodeServer === void 0 ? void 0 : nodeServer.on("upgrade", onHTTPUpgrade));
                   runner = api.useHookRunners();
-                  rsbuild === null || rsbuild === void 0 ? void 0 : rsbuild.onDevCompileDone(function(param) {
+                  builder === null || builder === void 0 ? void 0 : builder.onDevCompileDone(function(param) {
                     var stats = param.stats;
                     if (stats.toJson({
                       all: false
@@ -47,21 +56,62 @@ var devPlugin = function(options) {
                       cb();
                     });
                   }));
+                  before = [];
+                  after = [];
+                  _dev_setupMiddlewares = dev.setupMiddlewares, setupMiddlewares = _dev_setupMiddlewares === void 0 ? [] : _dev_setupMiddlewares;
+                  if (((_dev_after = dev.after) === null || _dev_after === void 0 ? void 0 : _dev_after.length) || ((_dev_before = dev.before) === null || _dev_before === void 0 ? void 0 : _dev_before.length)) {
+                    setupMiddlewares.push(function(middlewares2) {
+                      var _middlewares, _middlewares1;
+                      (_middlewares = middlewares2).unshift.apply(_middlewares, _to_consumable_array(dev.before || []));
+                      (_middlewares1 = middlewares2).push.apply(_middlewares1, _to_consumable_array(dev.after || []));
+                    });
+                  }
+                  setupMiddlewares.forEach(function(handler) {
+                    var _before, _after;
+                    handler({
+                      unshift: function() {
+                        for (var _len = arguments.length, handlers = new Array(_len), _key = 0; _key < _len; _key++) {
+                          handlers[_key] = arguments[_key];
+                        }
+                        return (_before = before).unshift.apply(_before, _to_consumable_array(handlers));
+                      },
+                      push: function() {
+                        for (var _len = arguments.length, handlers = new Array(_len), _key = 0; _key < _len; _key++) {
+                          handlers[_key] = arguments[_key];
+                        }
+                        return (_after = after).push.apply(_after, _to_consumable_array(handlers));
+                      }
+                    }, {
+                      sockWrite: function() {
+                      }
+                    });
+                  });
+                  before.forEach(function(middleware, index) {
+                    middlewares.push({
+                      name: "before-dev-server-".concat(index),
+                      handler: connectMid2HonoMid(middleware)
+                    });
+                  });
                   return [
                     4,
-                    registerMockHandlers({
-                      pwd,
-                      server: serverBase
-                    })
+                    getMockMiddleware(pwd)
                   ];
-                case 1:
-                  _state.sent();
-                  if (rsbuildMiddlewares) {
+                case 2:
+                  mockMiddleware = _state.sent();
+                  middlewares.push({
+                    name: "mock-dev",
+                    handler: mockMiddleware
+                  });
+                  builderMiddlewares && middlewares.push({
+                    name: "rsbuild-dev",
+                    handler: connectMid2HonoMid(builderMiddlewares)
+                  });
+                  after.forEach(function(middleware, index) {
                     middlewares.push({
-                      name: "rsbuild-dev",
-                      handler: connectMid2HonoMid(rsbuildMiddlewares)
+                      name: "after-dev-server-".concat(index),
+                      handler: connectMid2HonoMid(middleware)
                     });
-                  }
+                  });
                   middlewares.push({
                     name: "init-file-reader",
                     handler: initFileReader()

package/dist/esm/helpers/index.js

@@ -5,7 +5,7 @@ import { SERVER_BUNDLE_DIRECTORY, SERVER_DIR, logger } from "@modern-js/utils";
 import { AGGRED_DIR } from "@modern-js/server-core";
 import Watcher, { mergeWatchOptions } from "../dev-tools/watcher";
 import { debug } from "./utils";
-import { registerMockHandlers } from "./mock";
+import { initOrUpdateMockMiddlewares } from "./mock";
 export * from "./repack";
 export * from "./devOptions";
 export * from "./fileReader";
@@ -30,14 +30,11 @@ function _onServerChange() {
             ];
           return [
             4,
-            registerMockHandlers({
-              pwd,
-              server
-            })
+            initOrUpdateMockMiddlewares(pwd)
           ];
         case 1:
           _state.sent();
-          logger.info("Finish registering the mock handlers");
+          logger.info("Finish update the mock handlers");
           return [
             3,
             5

package/dist/esm/helpers/mock.js

@@ -5,6 +5,9 @@ import path from "node:path";
 import { fs } from "@modern-js/utils";
 import { AGGRED_DIR } from "@modern-js/server-core";
 import { connectMid2HonoMid } from "@modern-js/server-core/node";
+import { match } from "path-to-regexp";
+var mockAPIs = [];
+var mockConfig;
 var parseKey = function(key) {
   var _blank = " ";
   var splitted = key.split(_blank).filter(Boolean);
@@ -20,14 +23,12 @@ var parseKey = function(key) {
     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;
+var getMockModule = function() {
+  var _ref = _async_to_generator(function(pwd) {
+    var exts, mockFilePath, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, ext, maybeMatch, err, _ref2, mockHandlers, config, enable;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          pwd = param.pwd, server = param.server;
           exts = [
             ".ts",
             ".js"
@@ -101,7 +102,7 @@ var registerMockHandlers = function() {
           if (!mockFilePath) {
             return [
               2,
-              null
+              void 0
             ];
           }
           return [
@@ -109,95 +110,157 @@ var registerMockHandlers = function() {
             import(mockFilePath)
           ];
         case 9:
-          _ref2 = _state.sent(), mockModule = _ref2.default, config = _ref2.config;
+          _ref2 = _state.sent(), mockHandlers = _ref2.default, config = _ref2.config;
           enable = config === null || config === void 0 ? void 0 : config.enable;
           if (enable === false) {
             return [
-              2
+              2,
+              void 0
             ];
           }
-          if (!mockModule) {
+          if (!mockHandlers) {
             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);
-            var mockInfo = mockHandlerRegistry.get(handlerId);
-            if (mockInfo) {
-              mockInfo.handler = handler;
-            } else {
-              mockHandlerRegistry.set(handlerId, {
-                handler,
-                isRegistered: false
-              });
+          return [
+            2,
+            {
+              mockHandlers,
+              config
             }
-            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 function getMockModule2(pwd) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var getMatched = function(request, mockApis) {
+  var targetPathname = request.path, targetMethod = request.method;
+  var matched = mockApis.find(function(mockApi) {
+    var method = mockApi.method, pathname = mockApi.path;
+    if (method.toLowerCase() === targetMethod.toLowerCase()) {
+      return match(pathname, {
+        encode: encodeURI,
+        decode: decodeURIComponent
+      })(targetPathname);
+    }
+    return false;
+  });
+  return matched;
+};
+function initOrUpdateMockMiddlewares(pwd) {
+  return _initOrUpdateMockMiddlewares.apply(this, arguments);
+}
+function _initOrUpdateMockMiddlewares() {
+  _initOrUpdateMockMiddlewares = _async_to_generator(function(pwd) {
+    var mockModule;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            getMockModule(pwd)
+          ];
+        case 1:
+          mockModule = _state.sent();
+          mockConfig = mockModule === null || mockModule === void 0 ? void 0 : mockModule.config;
+          mockAPIs = Object.entries((mockModule === null || mockModule === void 0 ? void 0 : mockModule.mockHandlers) || {}).map(function(param) {
+            var _param = _sliced_to_array(param, 2), key = _param[0], handler = _param[1];
+            var _parseKey = parseKey(key), method = _parseKey.method, path2 = _parseKey.path;
+            return {
+              method,
+              path: path2,
+              handler
+            };
+          });
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _initOrUpdateMockMiddlewares.apply(this, arguments);
+}
+function getMockMiddleware(pwd) {
+  return _getMockMiddleware.apply(this, arguments);
+}
+function _getMockMiddleware() {
+  _getMockMiddleware = _async_to_generator(function(pwd) {
+    var mockMiddleware;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            initOrUpdateMockMiddlewares(pwd)
+          ];
+        case 1:
+          _state.sent();
+          mockMiddleware = function() {
+            var _ref = _async_to_generator(function(c, next) {
+              var isEnabled, matchedMockAPI, handler;
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    if (typeof (mockConfig === null || mockConfig === void 0 ? void 0 : mockConfig.enable) === "function") {
+                      isEnabled = mockConfig.enable(c.env.node.req, c.env.node.res);
+                      if (!isEnabled) {
                         return [
                           2,
-                          c.json(handler2)
-                        ];
-                      case 3:
-                        return [
-                          2
+                          next()
                         ];
+                      }
                     }
-                  });
-                });
-                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;
-              }
-            }
-          });
+                    matchedMockAPI = getMatched(c.req, mockAPIs);
+                    if (!matchedMockAPI)
+                      return [
+                        3,
+                        3
+                      ];
+                    handler = matchedMockAPI.handler;
+                    if (!(typeof handler === "function"))
+                      return [
+                        3,
+                        2
+                      ];
+                    return [
+                      4,
+                      connectMid2HonoMid(handler)(c, next)
+                    ];
+                  case 1:
+                    return [
+                      2,
+                      _state2.sent()
+                    ];
+                  case 2:
+                    return [
+                      2,
+                      c.json(handler)
+                    ];
+                  case 3:
+                    return [
+                      2,
+                      next()
+                    ];
+                }
+              });
+            });
+            return function mockMiddleware2(c, next) {
+              return _ref.apply(this, arguments);
+            };
+          }();
           return [
-            2
+            2,
+            mockMiddleware
           ];
       }
     });
   });
-  return function registerMockHandlers2(_) {
-    return _ref.apply(this, arguments);
-  };
-}();
+  return _getMockMiddleware.apply(this, arguments);
+}
 export {
-  registerMockHandlers
+  getMatched,
+  getMockMiddleware,
+  initOrUpdateMockMiddlewares
 };

package/dist/esm-node/createDevServer.js

@@ -3,7 +3,7 @@ import { createServerBase } from "@modern-js/server-core";
 import { createNodeServer, loadServerRuntimeConfig } from "@modern-js/server-core/node";
 import { getDevOptions } from "./helpers";
 import { devPlugin } from "./dev";
-const createDevServer = async (options, applyPlugins) => {
+async function createDevServer(options, applyPlugins) {
   const { config, pwd, serverConfigFile, serverConfigPath } = options;
   const dev = getDevOptions(options);
   const distDir = path.resolve(pwd, config.output.path || "dist");
@@ -30,8 +30,16 @@ const createDevServer = async (options, applyPlugins) => {
   ]);
   await applyPlugins(server, prodServerOptions, nodeServer);
   await server.init();
+  nodeServer.listen({
+    host: dev.host || "127.0.0.1",
+    port: dev.port || "8080"
+  }, (err) => {
+    if (err) {
+      throw err;
+    }
+  });
   return nodeServer;
-};
+}
 export {
   createDevServer
 };

package/dist/esm-node/dev.js

@@ -1,20 +1,24 @@
 import { connectMid2HonoMid } from "@modern-js/server-core/node";
 import { API_DIR, SHARED_DIR } from "@modern-js/utils";
-import { startWatcher, onRepack, getDevOptions, initFileReader, registerMockHandlers } from "./helpers";
+import { startWatcher, onRepack, getDevOptions, initFileReader, getMockMiddleware } from "./helpers";
 const devPlugin = (options) => ({
   name: "@modern-js/plugin-dev",
   setup(api) {
-    const { getMiddlewares, rsbuild, config, pwd } = options;
+    const { config, pwd, builder } = options;
     const closeCb = [];
-    const { middlewares: rsbuildMiddlewares, close, onHTTPUpgrade } = (getMiddlewares === null || getMiddlewares === void 0 ? void 0 : getMiddlewares()) || {};
-    close && closeCb.push(close);
     const dev = getDevOptions(options);
     return {
       async prepare() {
+        var _dev_after, _dev_before;
+        const builderDevServer = await (builder === null || builder === void 0 ? void 0 : builder.createDevServer({
+          runCompile: options.runCompile
+        }));
+        const { middlewares: builderMiddlewares, close, onHTTPUpgrade } = builderDevServer || {};
+        close && closeCb.push(close);
         const { middlewares, distDirectory, nodeServer, apiDirectory, sharedDirectory, serverBase } = api.useAppContext();
         onHTTPUpgrade && (nodeServer === null || nodeServer === void 0 ? void 0 : nodeServer.on("upgrade", onHTTPUpgrade));
         const runner = api.useHookRunners();
-        rsbuild === null || rsbuild === void 0 ? void 0 : rsbuild.onDevCompileDone(({ stats }) => {
+        builder === null || builder === void 0 ? void 0 : builder.onDevCompileDone(({ stats }) => {
           if (stats.toJson({
             all: false
           }).name !== "server") {
@@ -38,16 +42,45 @@ const devPlugin = (options) => ({
             cb();
           });
         }));
-        await registerMockHandlers({
-          pwd,
-          server: serverBase
+        const before = [];
+        const after = [];
+        const { setupMiddlewares = [] } = dev;
+        if (((_dev_after = dev.after) === null || _dev_after === void 0 ? void 0 : _dev_after.length) || ((_dev_before = dev.before) === null || _dev_before === void 0 ? void 0 : _dev_before.length)) {
+          setupMiddlewares.push((middlewares2) => {
+            middlewares2.unshift(...dev.before || []);
+            middlewares2.push(...dev.after || []);
+          });
+        }
+        setupMiddlewares.forEach((handler) => {
+          handler({
+            unshift: (...handlers) => before.unshift(...handlers),
+            push: (...handlers) => after.push(...handlers)
+          }, {
+            sockWrite: () => {
+            }
+          });
         });
-        if (rsbuildMiddlewares) {
+        before.forEach((middleware, index) => {
           middlewares.push({
-            name: "rsbuild-dev",
-            handler: connectMid2HonoMid(rsbuildMiddlewares)
+            name: `before-dev-server-${index}`,
+            handler: connectMid2HonoMid(middleware)
           });
-        }
+        });
+        const mockMiddleware = await getMockMiddleware(pwd);
+        middlewares.push({
+          name: "mock-dev",
+          handler: mockMiddleware
+        });
+        builderMiddlewares && middlewares.push({
+          name: "rsbuild-dev",
+          handler: connectMid2HonoMid(builderMiddlewares)
+        });
+        after.forEach((middleware, index) => {
+          middlewares.push({
+            name: `after-dev-server-${index}`,
+            handler: connectMid2HonoMid(middleware)
+          });
+        });
         middlewares.push({
           name: "init-file-reader",
           handler: initFileReader()

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

@@ -3,7 +3,7 @@ import { SERVER_BUNDLE_DIRECTORY, SERVER_DIR, logger } from "@modern-js/utils";
 import { AGGRED_DIR } from "@modern-js/server-core";
 import Watcher, { mergeWatchOptions } from "../dev-tools/watcher";
 import { debug } from "./utils";
-import { registerMockHandlers } from "./mock";
+import { initOrUpdateMockMiddlewares } from "./mock";
 export * from "./repack";
 export * from "./devOptions";
 export * from "./fileReader";
@@ -13,11 +13,8 @@ async function onServerChange({ pwd, filepath, event, server }) {
   const mockPath = path.normalize(path.join(pwd, mock));
   const { runner } = server;
   if (filepath.startsWith(mockPath)) {
-    await registerMockHandlers({
-      pwd,
-      server
-    });
-    logger.info("Finish registering the mock handlers");
+    await initOrUpdateMockMiddlewares(pwd);
+    logger.info("Finish update the mock handlers");
   } else {
     try {
       const fileChangeEvent = {

package/dist/esm-node/helpers/mock.js

@@ -2,6 +2,9 @@ import path from "node:path";
 import { fs } from "@modern-js/utils";
 import { AGGRED_DIR } from "@modern-js/server-core";
 import { connectMid2HonoMid } from "@modern-js/server-core/node";
+import { match } from "path-to-regexp";
+let mockAPIs = [];
+let mockConfig;
 const parseKey = (key) => {
   const _blank = " ";
   const splitted = key.split(_blank).filter(Boolean);
@@ -17,8 +20,7 @@ const parseKey = (key) => {
     path: key
   };
 };
-const mockHandlerRegistry = /* @__PURE__ */ new Map();
-const registerMockHandlers = async ({ pwd, server }) => {
+const getMockModule = async (pwd) => {
   const exts = [
     ".ts",
     ".js"
@@ -32,53 +34,71 @@ const registerMockHandlers = async ({ pwd, server }) => {
     }
   }
   if (!mockFilePath) {
-    return null;
+    return void 0;
   }
-  const { default: mockModule, config } = await import(mockFilePath);
+  const { default: mockHandlers, config } = await import(mockFilePath);
   const enable = config === null || config === void 0 ? void 0 : config.enable;
   if (enable === false) {
-    return;
+    return void 0;
   }
-  if (!mockModule) {
+  if (!mockHandlers) {
     throw new Error(`Mock file ${mockFilePath} parsed failed!`);
   }
-  Object.entries(mockModule).forEach(([key, handler]) => {
+  return {
+    mockHandlers,
+    config
+  };
+};
+const getMatched = (request, mockApis) => {
+  const { path: targetPathname, method: targetMethod } = request;
+  const matched = mockApis.find((mockApi) => {
+    const { method, path: pathname } = mockApi;
+    if (method.toLowerCase() === targetMethod.toLowerCase()) {
+      return match(pathname, {
+        encode: encodeURI,
+        decode: decodeURIComponent
+      })(targetPathname);
+    }
+    return false;
+  });
+  return matched;
+};
+async function initOrUpdateMockMiddlewares(pwd) {
+  const mockModule = await getMockModule(pwd);
+  mockConfig = mockModule === null || mockModule === void 0 ? void 0 : mockModule.config;
+  mockAPIs = Object.entries((mockModule === null || mockModule === void 0 ? void 0 : mockModule.mockHandlers) || {}).map(([key, handler]) => {
     const { method, path: path2 } = parseKey(key);
-    const methodName = method.toLowerCase();
-    const handlerId = `${methodName}-${path2}`;
-    const mockInfo = mockHandlerRegistry.get(handlerId);
-    if (mockInfo) {
-      mockInfo.handler = handler;
-    } else {
-      mockHandlerRegistry.set(handlerId, {
-        handler,
-        isRegistered: false
-      });
+    return {
+      method,
+      path: path2,
+      handler
+    };
+  });
+}
+async function getMockMiddleware(pwd) {
+  await initOrUpdateMockMiddlewares(pwd);
+  const mockMiddleware = async (c, next) => {
+    if (typeof (mockConfig === null || mockConfig === void 0 ? void 0 : mockConfig.enable) === "function") {
+      const isEnabled = mockConfig.enable(c.env.node.req, c.env.node.res);
+      if (!isEnabled) {
+        return next();
+      }
     }
-    if (typeof server[methodName] === "function") {
-      const mockHandler = async (c, next) => {
-        var _mockHandlerRegistry_get;
-        if (typeof enable === "function") {
-          const isEnabled = enable(c.env.node.req, c.env.node.res);
-          if (!isEnabled) {
-            return next();
-          }
-        }
-        const handler2 = (_mockHandlerRegistry_get = mockHandlerRegistry.get(handlerId)) === null || _mockHandlerRegistry_get === void 0 ? void 0 : _mockHandlerRegistry_get.handler;
-        if (typeof handler2 === "function") {
-          await connectMid2HonoMid(handler2)(c, next);
-        } else {
-          return c.json(handler2);
-        }
-      };
-      const handlerInfo = mockHandlerRegistry.get(handlerId);
-      if (handlerInfo && !(handlerInfo === null || handlerInfo === void 0 ? void 0 : handlerInfo.isRegistered)) {
-        server[methodName](path2, mockHandler);
-        handlerInfo.isRegistered = true;
+    const matchedMockAPI = getMatched(c.req, mockAPIs);
+    if (matchedMockAPI) {
+      const { handler } = matchedMockAPI;
+      if (typeof handler === "function") {
+        return await connectMid2HonoMid(handler)(c, next);
+      } else {
+        return c.json(handler);
       }
     }
-  });
-};
+    return next();
+  };
+  return mockMiddleware;
+}
 export {
-  registerMockHandlers
+  getMatched,
+  getMockMiddleware,
+  initOrUpdateMockMiddlewares
 };

package/dist/types/createDevServer.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
-import { Server as NodeServer } from 'node:http';
-import { ServerBaseOptions } from '@modern-js/server-core';
+/// <reference types="node" />
 import { ApplyPlugins, ModernDevServerOptions } from './types';
-export type { ModernDevServerOptions } from './types';
-export declare const createDevServer: <O extends ServerBaseOptions>(options: ModernDevServerOptions<O>, applyPlugins: ApplyPlugins<O>) => Promise<NodeServer>;
+export declare function createDevServer(options: ModernDevServerOptions, applyPlugins: ApplyPlugins): Promise<(import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> | import("https").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>) & {
+    getRequestListener: () => (req: import("http").IncomingMessage, res: import("http").ServerResponse) => Promise<void>;
+    getRequestHandler: () => import("@modern-js/server-core/dist/types/types").RequestHandler;
+}>;

package/dist/types/helpers/devOptions.d.ts

@@ -1,4 +1,5 @@
 import { ModernDevServerOptions } from '../types';
 export declare const getDevOptions: (options: ModernDevServerOptions) => import("@modern-js/types/server/devServer").DevServerOptions & Pick<import("@modern-js/types/server/devServer").DevServerOptions, "watch" | "https"> & {
-    writeToDisk?: boolean | ((filename: string) => boolean) | undefined;
+    port?: number | undefined;
+    host?: string | undefined;
 };

package/dist/types/helpers/mock.d.ts

@@ -1,5 +1,17 @@
-import { type ServerBase } from '@modern-js/server-core';
-export declare const registerMockHandlers: ({ pwd, server, }: {
-    pwd: string;
-    server: ServerBase;
-}) => Promise<null | undefined>;
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { NextFunction } from '@modern-js/types';
+import { type Middleware, InternalRequest } from '@modern-js/server-core';
+/** Types: Mock  */
+type MockHandler = {
+    data: any;
+} | ((req: IncomingMessage, res: ServerResponse, next: NextFunction) => Promise<void> | void);
+type MockAPI = {
+    method: string;
+    path: string;
+    handler: MockHandler;
+};
+export declare const getMatched: (request: InternalRequest, mockApis: MockAPI[]) => MockAPI | undefined;
+export declare function initOrUpdateMockMiddlewares(pwd: string): Promise<void>;
+export declare function getMockMiddleware(pwd: string): Promise<Middleware>;
+export {};

package/dist/types/index.d.ts

@@ -1,2 +1,2 @@
 export { createDevServer } from './createDevServer';
-export type { ModernDevServerOptions } from './createDevServer';
+export type { ModernDevServerOptions } from './types';

package/dist/types/types.d.ts

@@ -1,52 +1,18 @@
 /// <reference types="node" />
-/// <reference types="node" />
-import type { IncomingMessage, ServerResponse } from 'http';
-import type { Socket } from 'net';
-import type { DevServerOptions, DevServerHttpsOptions, NextFunction } from '@modern-js/types';
-import type { RsbuildInstance } from '@rsbuild/core';
+import type { UniBuilderInstance } from '@modern-js/uni-builder';
+import type { DevServerOptions, DevServerHttpsOptions } from '@modern-js/types';
 import { NodeServer, ServerBase, ServerBaseOptions } from '@modern-js/server-core';
 export type { DevServerOptions, DevServerHttpsOptions };
-type Middleware = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => Promise<void>;
-export type DevMiddlewareAPI = Middleware & {
-    close: (callback: (err: Error | null | undefined) => void) => any;
-};
-export type MiddlewareCallbacks = {
-    onInvalid: () => void;
-    onDone: (stats: any) => void;
-};
-export type DevMiddlewareOptions = {
-    /** To ensure HMR works, the devMiddleware need inject the hmr client path into page when HMR enable. */
-    hmrClientPath?: string;
-    /** The options need by compiler middleware (like webpackMiddleware) */
-    headers?: Record<string, string | string[]>;
-    writeToDisk?: boolean | ((filename: string) => boolean);
-    stats?: boolean;
-    /** should trigger when compiler hook called */
-    callbacks: MiddlewareCallbacks;
-    /** whether use Server Side Render */
-    serverSideRender?: boolean;
-};
-/**
- * The modern/server do nothing about compiler, the devMiddleware need do such things to ensure dev works well:
- * - Call compiler.watch （normally did by webpack-dev-middleware）.
- * - Inject the hmr client path into page （the hmr client modern/server already provide）.
- * - Notify server when compiler hooks are triggered.
- */
-export type DevMiddleware = (options: DevMiddlewareOptions) => DevMiddlewareAPI;
 export type ExtraOptions = {
     dev: Pick<DevServerOptions, 'watch' | 'https'> & {
-        writeToDisk?: boolean | ((filename: string) => boolean);
+        port?: number;
+        host?: string;
     };
+    runCompile?: boolean;
     /** compat, the default value is modern.server-runtime.config.ts  */
     serverConfigFile?: string;
     serverConfigPath?: string;
-    useSSRWorker?: boolean;
-    rsbuild: RsbuildInstance;
-    getMiddlewares?: () => {
-        middlewares: (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void;
-        onHTTPUpgrade: (req: IncomingMessage, socket: Socket, head: any) => void;
-        close: () => Promise<void>;
-    };
+    builder?: UniBuilderInstance;
 };
 export type ModernDevServerOptions<O extends ServerBaseOptions = ServerBaseOptions> = O & ExtraOptions;
 export type ApplyPlugins<O extends ServerBaseOptions = ServerBaseOptions> = (server: ServerBase, options: O, nodeServer?: NodeServer) => Promise<void>;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.56.0",
+  "version": "2.56.2",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -48,14 +48,13 @@
     "minimatch": "^3.0.4",
     "path-to-regexp": "^6.2.0",
     "ws": "^8.13.0",
-    "@modern-js/runtime-utils": "2.56.0",
-    "@modern-js/server-utils": "2.56.0",
-    "@modern-js/types": "2.56.0",
-    "@modern-js/utils": "2.56.0",
-    "@modern-js/server-core": "2.56.0"
+    "@modern-js/runtime-utils": "2.56.2",
+    "@modern-js/server-utils": "2.56.2",
+    "@modern-js/types": "2.56.2",
+    "@modern-js/utils": "2.56.2",
+    "@modern-js/server-core": "2.56.2"
   },
   "devDependencies": {
-    "@rsbuild/core": "1.0.1-beta.3",
     "@types/connect-history-api-fallback": "^1.3.5",
     "@types/jest": "^29",
     "@types/minimatch": "^3.0.5",
@@ -68,8 +67,9 @@
     "typescript": "^5",
     "webpack": "^5.93.0",
     "websocket": "^1",
-    "@scripts/build": "2.56.0",
-    "@scripts/jest-config": "2.56.0"
+    "@modern-js/uni-builder": "2.56.2",
+    "@scripts/jest-config": "2.56.2",
+    "@scripts/build": "2.56.2"
   },
   "peerDependencies": {
     "devcert": "^1.2.2",