@modern-js/server 2.42.2 → 2.44.0

package/dist/cjs/server/devServerOld.js

@@ -0,0 +1,352 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var devServerOld_exports = {};
+__export(devServerOld_exports, {
+  ModernDevServer: () => ModernDevServer
+});
+module.exports = __toCommonJS(devServerOld_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_http = require("http");
+var import_path = __toESM(require("path"));
+var import_https = require("https");
+var import_utils = require("@modern-js/utils");
+var import_prod_server = require("@modern-js/prod-server");
+var import_lodash = require("@modern-js/utils/lodash");
+var import_fileReader = require("@modern-js/runtime-utils/fileReader");
+var import_constants = require("../constants");
+var import_mock = require("../dev-tools/mock");
+var import_register = require("../dev-tools/register");
+var import_watcher = __toESM(require("../dev-tools/watcher"));
+var import_dev_middleware = __toESM(require("../dev-tools/dev-middleware"));
+var import_workerSSRRender = require("./workerSSRRender");
+class ModernDevServer extends import_prod_server.ModernServer {
+  getDevOptions(options) {
+    const devOptions = typeof options.dev === "boolean" ? {} : options.dev;
+    const defaultOptions = (0, import_constants.getDefaultDevOptions)();
+    return (0, import_lodash.merge)(defaultOptions, devOptions);
+  }
+  addMiddlewareHandler(handlers) {
+    handlers.forEach((handler) => {
+      this.addHandler((ctx, next) => {
+        const { req, res } = ctx;
+        return handler(req, res, next);
+      });
+    });
+  }
+  applySetupMiddlewares() {
+    const setupMiddlewares = this.dev.setupMiddlewares || [];
+    const serverOptions = {
+      sockWrite: (type, data) => this.devMiddleware.sockWrite(type, data)
+    };
+    const befores = [];
+    const afters = [];
+    setupMiddlewares.forEach((handler) => {
+      handler({
+        unshift: (...handlers) => befores.unshift(...handlers),
+        push: (...handlers) => afters.push(...handlers)
+      }, serverOptions);
+    });
+    return {
+      befores,
+      afters
+    };
+  }
+  // Complete the preparation of services
+  async onInit(runner, app) {
+    this.runner = runner;
+    const { dev } = this;
+    const { befores, afters } = this.applySetupMiddlewares();
+    const beforeHandlers = this.dev.before || [];
+    this.addMiddlewareHandler([
+      ...beforeHandlers,
+      ...befores
+    ]);
+    await this.applyDefaultMiddlewares(app);
+    const afterHandlers = this.dev.after || [];
+    this.addMiddlewareHandler([
+      ...afters,
+      ...afterHandlers
+    ]);
+    this.initFileReader();
+    await super.onInit(runner, app);
+    if (dev.watch) {
+      this.startWatcher();
+      app.on("close", async () => {
+        var _this_watcher;
+        await ((_this_watcher = this.watcher) === null || _this_watcher === void 0 ? void 0 : _this_watcher.close());
+      });
+    }
+  }
+  // override the ModernServer renderHandler logic
+  getRenderHandler() {
+    if (this.useWorkerSSR) {
+      var _this_conf_server, _conf_security;
+      const { distDir, staticGenerate, conf, metaName } = this;
+      const ssrConfig = (_this_conf_server = this.conf.server) === null || _this_conf_server === void 0 ? void 0 : _this_conf_server.ssr;
+      const forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
+      return (0, import_prod_server.createRenderHandler)({
+        ssrRender: import_workerSSRRender.workerSSRRender,
+        distDir,
+        staticGenerate,
+        conf,
+        forceCSR,
+        nonce: (_conf_security = conf.security) === null || _conf_security === void 0 ? void 0 : _conf_security.nonce,
+        metaName
+      });
+    }
+    return super.getRenderHandler();
+  }
+  initFileReader() {
+    var _this_dev_devMiddleware, _this_dev;
+    let isInit = false;
+    if (((_this_dev = this.dev) === null || _this_dev === void 0 ? void 0 : (_this_dev_devMiddleware = _this_dev.devMiddleware) === null || _this_dev_devMiddleware === void 0 ? void 0 : _this_dev_devMiddleware.writeToDisk) === false) {
+      this.addHandler((ctx, next) => {
+        var _ctx_res_locals;
+        if (isInit) {
+          return next();
+        }
+        isInit = true;
+        if (!((_ctx_res_locals = ctx.res.locals) === null || _ctx_res_locals === void 0 ? void 0 : _ctx_res_locals.webpack)) {
+          import_fileReader.fileReader.reset();
+          return next();
+        }
+        const { devMiddleware: webpackDevMid } = ctx.res.locals.webpack;
+        const { outputFileSystem } = webpackDevMid;
+        if (outputFileSystem) {
+          import_fileReader.fileReader.reset(outputFileSystem);
+        } else {
+          import_fileReader.fileReader.reset();
+        }
+        return next();
+      });
+    }
+  }
+  async applyDefaultMiddlewares(app) {
+    const { pwd, dev, devMiddleware, conf } = this;
+    const isUseStreamingSSR = (routes) => routes === null || routes === void 0 ? void 0 : routes.some((r) => r.isStream === true);
+    const isUseSSRPreload = () => {
+      const { server: { ssr, ssrByEntries } } = conf;
+      const checkUsePreload = (ssr2) => typeof ssr2 === "object" && Boolean(ssr2.preload);
+      return checkUsePreload(ssr) || Object.values(ssrByEntries || {}).some((ssr2) => checkUsePreload(ssr2));
+    };
+    if (!isUseStreamingSSR(this.getRoutes()) && !isUseSSRPreload() && dev.compress) {
+      const { default: compression } = await Promise.resolve().then(() => __toESM(require("http-compression")));
+      this.addHandler((ctx, next) => {
+        compression({
+          gzip: true,
+          brotli: false
+        })(ctx.req, ctx.res, next);
+      });
+    }
+    this.addHandler((ctx, next) => {
+      ctx.res.setHeader("Access-Control-Allow-Origin", "*");
+      if (ctx.path.includes("hot-update")) {
+        ctx.res.setHeader("Access-Control-Allow-Credentials", "false");
+      }
+      const confHeaders = dev.headers;
+      if (confHeaders) {
+        for (const [key, value] of Object.entries(confHeaders)) {
+          ctx.res.setHeader(key, value);
+        }
+      }
+      next();
+    });
+    this.mockHandler = (0, import_mock.createMockHandler)({
+      pwd
+    });
+    this.addHandler((ctx, next) => {
+      if (this.mockHandler) {
+        this.mockHandler(ctx, next);
+      } else {
+        next();
+      }
+    });
+    if (dev.proxy) {
+      const { handlers, handleUpgrade } = (0, import_prod_server.createProxyHandler)(dev.proxy);
+      app && handleUpgrade(app);
+      handlers.forEach((handler) => {
+        this.addHandler(handler);
+      });
+    }
+    devMiddleware.init(app);
+    devMiddleware.on("change", (stats) => {
+      if (stats.toJson({
+        all: false
+      }).name !== "server") {
+        this.onRepack({
+          routes: this.getRoutes()
+        });
+      }
+    });
+    this.addHandler((ctx, next) => {
+      const { req, res } = ctx;
+      if (devMiddleware.middleware) {
+        devMiddleware.middleware(req, res, next);
+      } else {
+        next();
+      }
+    });
+    if (dev.historyApiFallback) {
+      const { default: connectHistoryApiFallback } = await Promise.resolve().then(() => __toESM(require("connect-history-api-fallback")));
+      const historyApiFallbackMiddleware = connectHistoryApiFallback(typeof dev.historyApiFallback === "boolean" ? {} : dev.historyApiFallback);
+      this.addHandler((ctx, next) => historyApiFallbackMiddleware(ctx.req, ctx.res, next));
+    }
+  }
+  onRepack(options = {}) {
+    if (Array.isArray(options.routes)) {
+      this.router.reset(this.filterRoutes(options.routes));
+    }
+    this.cleanSSRCache();
+    import_fileReader.fileReader.reset();
+    this.runner.repack();
+    super.onRepack(options);
+  }
+  async createHTTPServer(handler) {
+    const { dev } = this;
+    const devHttpsOption = typeof dev === "object" && dev.https;
+    if (devHttpsOption) {
+      const { genHttpsOptions } = require("../dev-tools/https");
+      const httpsOptions = await genHttpsOptions(devHttpsOption, this.pwd);
+      return (0, import_https.createServer)(httpsOptions, handler);
+    } else {
+      return (0, import_http.createServer)(handler);
+    }
+  }
+  warmupSSRBundle() {
+  }
+  async onServerChange({ filepath, event }) {
+    const { pwd } = this;
+    const { mock } = import_prod_server.AGGRED_DIR;
+    const mockPath = import_path.default.normalize(import_path.default.join(pwd, mock));
+    this.runner.reset();
+    if (filepath.startsWith(mockPath)) {
+      this.mockHandler = (0, import_mock.createMockHandler)({
+        pwd
+      });
+    } else {
+      try {
+        const success = this.runner.onApiChange([
+          {
+            filename: filepath,
+            event
+          }
+        ]);
+        if (success !== true) {
+          await super.onServerChange({
+            filepath
+          });
+        }
+      } catch (e) {
+        this.logger.error(e);
+      }
+    }
+  }
+  createContext(req, res) {
+    return super.createContext(req, res, {
+      etag: true,
+      metaName: this.metaName
+    });
+  }
+  setupStaticMiddleware(_) {
+    return async (context, next) => {
+      return next();
+    };
+  }
+  cleanSSRCache() {
+    const { distDir } = this;
+    const bundles = this.router.getBundles();
+    bundles.forEach((bundle) => {
+      const filepath = import_path.default.join(distDir, bundle);
+      if (require.cache[filepath]) {
+        delete require.cache[filepath];
+      }
+    });
+    const loadable = import_path.default.join(distDir, import_utils.LOADABLE_STATS_FILE);
+    if (require.cache[loadable]) {
+      delete require.cache[loadable];
+    }
+  }
+  startWatcher() {
+    var _this_conf_server;
+    const { pwd, distDir, appContext } = this;
+    const { mock } = import_prod_server.AGGRED_DIR;
+    const apiDir = (appContext === null || appContext === void 0 ? void 0 : appContext.apiDirectory) || import_utils.API_DIR;
+    const sharedDir = (appContext === null || appContext === void 0 ? void 0 : appContext.sharedDirectory) || import_utils.SHARED_DIR;
+    const defaultWatched = [
+      `${mock}/**/*`,
+      `${import_utils.SERVER_DIR}/**/*`,
+      `${apiDir}/**`,
+      `${sharedDir}/**/*`,
+      `${distDir}/${import_utils.SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
+    ];
+    const watchOptions = (0, import_watcher.mergeWatchOptions)((_this_conf_server = this.conf.server) === null || _this_conf_server === void 0 ? void 0 : _this_conf_server.watchOptions);
+    const defaultWatchedPaths = defaultWatched.map((p) => {
+      const finalPath = import_path.default.isAbsolute(p) ? p : import_path.default.join(pwd, p);
+      return import_path.default.normalize(finalPath);
+    });
+    const watcher = new import_watcher.default();
+    watcher.createDepTree();
+    watcher.listen(defaultWatchedPaths, watchOptions, (filepath, event) => {
+      if (filepath.includes("-server-loaders.js")) {
+        delete require.cache[filepath];
+        return;
+      } else {
+        watcher.updateDepTree();
+        watcher.cleanDepCache(filepath);
+      }
+      this.onServerChange({
+        filepath,
+        event
+      });
+    });
+    this.watcher = watcher;
+  }
+  constructor(options) {
+    super(options);
+    (0, import_define_property._)(this, "mockHandler", null);
+    (0, import_define_property._)(this, "dev", void 0);
+    (0, import_define_property._)(this, "useWorkerSSR", void 0);
+    (0, import_define_property._)(this, "appContext", void 0);
+    (0, import_define_property._)(this, "devMiddleware", void 0);
+    (0, import_define_property._)(this, "watcher", void 0);
+    this.appContext = options.appContext;
+    this.workDir = this.pwd;
+    this.useWorkerSSR = Boolean(options.useWorkerSSR);
+    this.dev = this.getDevOptions(options);
+    this.devMiddleware = new import_dev_middleware.default({
+      dev: this.dev,
+      devMiddleware: options.devMiddleware
+    });
+    (0, import_register.enableRegister)(this.pwd, this.conf);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModernDevServer
+});

package/dist/cjs/server/index.js

@@ -18,13 +18,15 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var server_exports = {};
 __export(server_exports, {
-  DevServer: () => DevServer
+  DevServer: () => DevServer,
+  DevServerForRsbuild: () => DevServerForRsbuild
 });
 module.exports = __toCommonJS(server_exports);
 var import_prod_server = require("@modern-js/prod-server");
+var import_devServerOld = require("./devServerOld");
 var import_devServer = require("./devServer");
 const createDevServer = (options) => {
-  return new import_devServer.ModernDevServer(options);
+  return new import_devServerOld.ModernDevServer(options);
 };
 class DevServer extends import_prod_server.Server {
   constructor(options) {
@@ -34,7 +36,16 @@ class DevServer extends import_prod_server.Server {
     }
   }
 }
+class DevServerForRsbuild extends import_prod_server.Server {
+  constructor(options) {
+    super(options);
+    if (options.dev) {
+      this.serverImpl = (options2) => new import_devServer.ModernDevServer(options2);
+    }
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DevServer
+  DevServer,
+  DevServerForRsbuild
 });

package/dist/cjs/server/workerSSRRender.js

@@ -36,7 +36,7 @@ var import_utils = require("@modern-js/utils");
 const PORT = 9230;
 async function workerSSRRender(ctx, renderOptions, _runner) {
   const { headers, params } = ctx;
-  const { urlPath } = renderOptions;
+  const { urlPath } = renderOptions.route;
   const url = `http://0.0.0.0:${PORT}/${urlPath}`;
   const resposne = await import_axios.default.get(url, {
     timeout: 5e3,

package/dist/esm/dev-tools/dev-middleware/hmr-client/createSocketUrl.js

@@ -28,7 +28,7 @@ function createSocketUrl(resourceQuery) {
 }
 function formatURL(param) {
   var port = param.port, protocol = param.protocol, hostname = param.hostname, pathname = param.pathname;
-  if (window.URL) {
+  if (typeof URL !== "undefined") {
     var url = new URL("http://localhost");
     url.port = port;
     url.hostname = hostname;

package/dist/esm/dev-tools/dev-middleware/index.js

@@ -19,8 +19,7 @@ function getHMRClientPath(client) {
   var clientEntry = "".concat(require.resolve("@modern-js/server/hmr-client"), "?").concat(host).concat(path).concat(port).concat(protocol);
   return clientEntry;
 }
-var DevMiddleware;
-DevMiddleware = /* @__PURE__ */ function(EventEmitter2) {
+var DevMiddleware = /* @__PURE__ */ function(EventEmitter2) {
   "use strict";
   _inherits(DevMiddleware2, EventEmitter2);
   var _super = _create_super(DevMiddleware2);

package/dist/esm/dev-tools/dev-middleware/socketServer.js

@@ -3,8 +3,7 @@ import { _ as _create_class } from "@swc/helpers/_/_create_class";
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import ws from "ws";
 import { logger } from "@modern-js/utils";
-var SocketServer;
-SocketServer = /* @__PURE__ */ function() {
+var SocketServer = /* @__PURE__ */ function() {
   "use strict";
   function SocketServer2(options) {
     _class_call_check(this, SocketServer2);

package/dist/esm/dev-tools/watcher/index.js

@@ -38,8 +38,7 @@ var mergeWatchOptions = function(options) {
   var finalWatchOptions = _object_spread({}, defaultWatchOptions, watchOptions);
   return finalWatchOptions;
 };
-var Watcher;
-Watcher = /* @__PURE__ */ function() {
+var Watcher = /* @__PURE__ */ function() {
   "use strict";
   function Watcher2() {
     _class_call_check(this, Watcher2);

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-import { DevServer as Server } from "./server";
+import { DevServer as Server, DevServerForRsbuild as ServerForRsbuild } from "./server";
 function src_default(options) {
   if (options == null) {
     throw new Error("can not start server without options");
@@ -9,5 +9,6 @@ function src_default(options) {
 ;
 export {
   Server,
+  ServerForRsbuild,
   src_default as default
 };