@modern-js/server 2.48.6 → 2.49.0

package/dist/esm/helpers/index.js

@@ -0,0 +1,119 @@
+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 { SERVER_BUNDLE_DIRECTORY, SERVER_DIR, logger } from "@modern-js/utils";
+import { AGGRED_DIR } from "@modern-js/server-core/base";
+import { registerMockHandlers } from "@modern-js/server-core/base/node";
+import Watcher, { mergeWatchOptions } from "../dev-tools/watcher";
+import { debug } from "./utils";
+export * from "./repack";
+export * from "./devOptions";
+export * from "./fileReader";
+function onServerChange(_) {
+  return _onServerChange.apply(this, arguments);
+}
+function _onServerChange() {
+  _onServerChange = _async_to_generator(function(param) {
+    var pwd, filepath, event, server, mock, mockPath, runner, e;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          pwd = param.pwd, filepath = param.filepath, event = param.event, server = param.server;
+          mock = AGGRED_DIR.mock;
+          mockPath = path.normalize(path.join(pwd, mock));
+          runner = server.runner;
+          runner.reset();
+          if (!filepath.startsWith(mockPath))
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            registerMockHandlers({
+              pwd,
+              server
+            })
+          ];
+        case 1:
+          _state.sent();
+          logger.info("Finish registering the mock handlers");
+          return [
+            3,
+            5
+          ];
+        case 2:
+          _state.trys.push([
+            2,
+            4,
+            ,
+            5
+          ]);
+          return [
+            4,
+            runner.onApiChange([
+              {
+                filename: filepath,
+                event
+              }
+            ])
+          ];
+        case 3:
+          _state.sent();
+          debug("Finish reload server, trigger by ".concat(filepath, " ").concat(event));
+          return [
+            3,
+            5
+          ];
+        case 4:
+          e = _state.sent();
+          logger.error(e);
+          return [
+            3,
+            5
+          ];
+        case 5:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _onServerChange.apply(this, arguments);
+}
+function startWatcher(param) {
+  var pwd = param.pwd, distDir = param.distDir, apiDir = param.apiDir, sharedDir = param.sharedDir, watchOptions = param.watchOptions, server = param.server;
+  var mock = AGGRED_DIR.mock;
+  var defaultWatched = [
+    "".concat(mock, "/**/*"),
+    "".concat(SERVER_DIR, "/**/*"),
+    "".concat(apiDir, "/**"),
+    "".concat(sharedDir, "/**/*"),
+    "".concat(distDir, "/").concat(SERVER_BUNDLE_DIRECTORY, "/*-server-loaders.js")
+  ];
+  var mergedWatchOptions = mergeWatchOptions(watchOptions);
+  var defaultWatchedPaths = defaultWatched.map(function(p) {
+    var finalPath = path.isAbsolute(p) ? p : path.join(pwd, p);
+    return path.normalize(finalPath);
+  });
+  var watcher = new Watcher();
+  watcher.createDepTree();
+  watcher.listen(defaultWatchedPaths, mergedWatchOptions, function(filepath, event) {
+    if (filepath.includes("-server-loaders.js")) {
+      delete require.cache[filepath];
+    } else {
+      watcher.updateDepTree();
+      watcher.cleanDepCache(filepath);
+    }
+    onServerChange({
+      pwd,
+      filepath,
+      event,
+      server
+    });
+  });
+  return watcher;
+}
+export {
+  startWatcher
+};

package/dist/esm/helpers/repack.js

@@ -0,0 +1,31 @@
+import path from "path";
+import { LOADABLE_STATS_FILE } from "@modern-js/utils";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+var getBundles = function(routes) {
+  return routes.filter(function(route) {
+    return route.isSSR;
+  }).map(function(route) {
+    return route.bundle;
+  });
+};
+var cleanSSRCache = function(distDir, routes) {
+  var bundles = getBundles(routes);
+  bundles.forEach(function(bundle) {
+    var filepath = path.join(distDir, bundle);
+    if (require.cache[filepath]) {
+      delete require.cache[filepath];
+    }
+  });
+  var loadable = path.join(distDir, LOADABLE_STATS_FILE);
+  if (require.cache[loadable]) {
+    delete require.cache[loadable];
+  }
+};
+var onRepack = function(distDir, runner, routes) {
+  cleanSSRCache(distDir, routes);
+  fileReader.reset();
+  runner.repack();
+};
+export {
+  onRepack
+};

package/dist/esm/helpers/utils.js

@@ -0,0 +1,5 @@
+import { createDebugger } from "@modern-js/utils";
+var debug = createDebugger("server");
+export {
+  debug
+};

package/dist/esm/index.js

@@ -1,14 +1,4 @@
-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");
-  }
-  var server = new Server(options);
-  return server.init();
-}
-;
+import { createDevServer } from "./createDevServer";
 export {
-  Server,
-  ServerForRsbuild,
-  src_default as default
+  createDevServer
 };

package/dist/esm-node/createDevServer.js

@@ -0,0 +1,61 @@
+import path from "node:path";
+import { createServerBase } from "@modern-js/server-core/base";
+import { registerMockHandlers, createNodeServer, connectMid2HonoMid } from "@modern-js/server-core/base/node";
+import { API_DIR, SHARED_DIR } from "@modern-js/utils";
+import { startWatcher, onRepack, getDevOptions, initFileReader } from "./helpers";
+const createDevServer = async (options, initProdMiddlewares) => {
+  const { config, pwd, routes = [], getMiddlewares, rsbuild, appContext } = options;
+  const dev = getDevOptions(options);
+  const distDir = path.resolve(pwd, config.output.path || "dist");
+  const apiDir = (appContext === null || appContext === void 0 ? void 0 : appContext.apiDirectory) || API_DIR;
+  const sharedDir = (appContext === null || appContext === void 0 ? void 0 : appContext.sharedDirectory) || SHARED_DIR;
+  const prodServerOptions = {
+    ...options,
+    pwd: distDir
+  };
+  const server = createServerBase(prodServerOptions);
+  const closeCb = [];
+  await registerMockHandlers({
+    pwd,
+    server
+  });
+  const { middlewares: rsbuildMiddlewares, close, onHTTPUpgrade } = (getMiddlewares === null || getMiddlewares === void 0 ? void 0 : getMiddlewares()) || {};
+  close && closeCb.push(close);
+  rsbuildMiddlewares && server.all("*", connectMid2HonoMid(rsbuildMiddlewares));
+  server.use("*", initFileReader());
+  await server.init();
+  const nodeServer = createNodeServer(server.handle.bind(server));
+  rsbuild === null || rsbuild === void 0 ? void 0 : rsbuild.onDevCompileDone(({ stats }) => {
+    if (stats.toJson({
+      all: false
+    }).name !== "server") {
+      onRepack(distDir, server.runner, routes);
+    }
+  });
+  onHTTPUpgrade && nodeServer.on("upgrade", onHTTPUpgrade);
+  await server.runner.beforeServerInit({
+    app: nodeServer
+  });
+  await initProdMiddlewares(server, prodServerOptions);
+  if (dev.watch) {
+    const { watchOptions } = config.server;
+    const watcher = startWatcher({
+      pwd,
+      distDir,
+      apiDir,
+      sharedDir,
+      watchOptions,
+      server
+    });
+    closeCb.push(watcher.close.bind(watcher));
+  }
+  closeCb.length > 0 && nodeServer.on("close", () => {
+    closeCb.forEach((cb) => {
+      cb();
+    });
+  });
+  return nodeServer;
+};
+export {
+  createDevServer
+};

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

@@ -0,0 +1,10 @@
+import { merge } from "@modern-js/utils/lodash";
+import { getDefaultDevOptions } from "./constants";
+const getDevOptions = (options) => {
+  const devOptions = options.dev;
+  const defaultOptions = getDefaultDevOptions();
+  return merge(defaultOptions, devOptions);
+};
+export {
+  getDevOptions
+};

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

@@ -0,0 +1,27 @@
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+const initFileReader = () => {
+  let isInit = false;
+  return async (ctx, next) => {
+    var _res_locals;
+    if (isInit) {
+      return next();
+    }
+    isInit = true;
+    const { res } = ctx.env.node;
+    if (!((_res_locals = res.locals) === null || _res_locals === void 0 ? void 0 : _res_locals.webpack)) {
+      fileReader.reset();
+      return next();
+    }
+    const { devMiddleware: webpackDevMid } = res.locals.webpack;
+    const { outputFileSystem } = webpackDevMid;
+    if (outputFileSystem) {
+      fileReader.reset(outputFileSystem);
+    } else {
+      fileReader.reset();
+    }
+    return next();
+  };
+};
+export {
+  initFileReader
+};

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

@@ -0,0 +1,69 @@
+import path from "path";
+import { SERVER_BUNDLE_DIRECTORY, SERVER_DIR, logger } from "@modern-js/utils";
+import { AGGRED_DIR } from "@modern-js/server-core/base";
+import { registerMockHandlers } from "@modern-js/server-core/base/node";
+import Watcher, { mergeWatchOptions } from "../dev-tools/watcher";
+import { debug } from "./utils";
+export * from "./repack";
+export * from "./devOptions";
+export * from "./fileReader";
+async function onServerChange({ pwd, filepath, event, server }) {
+  const { mock } = AGGRED_DIR;
+  const mockPath = path.normalize(path.join(pwd, mock));
+  const { runner } = server;
+  runner.reset();
+  if (filepath.startsWith(mockPath)) {
+    await registerMockHandlers({
+      pwd,
+      server
+    });
+    logger.info("Finish registering the mock handlers");
+  } else {
+    try {
+      await runner.onApiChange([
+        {
+          filename: filepath,
+          event
+        }
+      ]);
+      debug(`Finish reload server, trigger by ${filepath} ${event}`);
+    } catch (e) {
+      logger.error(e);
+    }
+  }
+}
+function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server }) {
+  const { mock } = AGGRED_DIR;
+  const defaultWatched = [
+    `${mock}/**/*`,
+    `${SERVER_DIR}/**/*`,
+    `${apiDir}/**`,
+    `${sharedDir}/**/*`,
+    `${distDir}/${SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
+  ];
+  const mergedWatchOptions = mergeWatchOptions(watchOptions);
+  const defaultWatchedPaths = defaultWatched.map((p) => {
+    const finalPath = path.isAbsolute(p) ? p : path.join(pwd, p);
+    return path.normalize(finalPath);
+  });
+  const watcher = new Watcher();
+  watcher.createDepTree();
+  watcher.listen(defaultWatchedPaths, mergedWatchOptions, (filepath, event) => {
+    if (filepath.includes("-server-loaders.js")) {
+      delete require.cache[filepath];
+    } else {
+      watcher.updateDepTree();
+      watcher.cleanDepCache(filepath);
+    }
+    onServerChange({
+      pwd,
+      filepath,
+      event,
+      server
+    });
+  });
+  return watcher;
+}
+export {
+  startWatcher
+};

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

@@ -0,0 +1,27 @@
+import path from "path";
+import { LOADABLE_STATS_FILE } from "@modern-js/utils";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+const getBundles = (routes) => {
+  return routes.filter((route) => route.isSSR).map((route) => route.bundle);
+};
+const cleanSSRCache = (distDir, routes) => {
+  const bundles = getBundles(routes);
+  bundles.forEach((bundle) => {
+    const filepath = path.join(distDir, bundle);
+    if (require.cache[filepath]) {
+      delete require.cache[filepath];
+    }
+  });
+  const loadable = path.join(distDir, LOADABLE_STATS_FILE);
+  if (require.cache[loadable]) {
+    delete require.cache[loadable];
+  }
+};
+const onRepack = (distDir, runner, routes) => {
+  cleanSSRCache(distDir, routes);
+  fileReader.reset();
+  runner.repack();
+};
+export {
+  onRepack
+};

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

@@ -0,0 +1,5 @@
+import { createDebugger } from "@modern-js/utils";
+const debug = createDebugger("server");
+export {
+  debug
+};

package/dist/esm-node/index.js

@@ -1,13 +1,4 @@
-import { DevServer as Server, DevServerForRsbuild as ServerForRsbuild } from "./server";
-var src_default = (options) => {
-  if (options == null) {
-    throw new Error("can not start server without options");
-  }
-  const server = new Server(options);
-  return server.init();
-};
+import { createDevServer } from "./createDevServer";
 export {
-  Server,
-  ServerForRsbuild,
-  src_default as default
+  createDevServer
 };

package/dist/types/createDevServer.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { Server as NodeServer } from 'node:http';
+import { ServerBaseOptions } from '@modern-js/server-core/base';
+import { InitProdMiddlewares, ModernDevServerOptions } from './types';
+export type { ModernDevServerOptions, InitProdMiddlewares } from './types';
+export declare const createDevServer: <O extends ServerBaseOptions>(options: ModernDevServerOptions<O>, initProdMiddlewares: InitProdMiddlewares<O>) => Promise<NodeServer>;

package/dist/types/{constants.d.ts → helpers/constants.d.ts}

@@ -1,2 +1,2 @@
-import { DevServerOptions } from './types';
+import { DevServerOptions } from '../types';
 export declare const getDefaultDevOptions: () => DevServerOptions;

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

@@ -0,0 +1,4 @@
+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;
+};

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

@@ -0,0 +1,2 @@
+import { Middleware } from '@modern-js/server-core/base';
+export declare const initFileReader: () => Middleware;

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

@@ -0,0 +1,14 @@
+import { WatchOptions } from '@modern-js/utils';
+import { ServerBase } from '@modern-js/server-core/base';
+import Watcher from '../dev-tools/watcher';
+export * from './repack';
+export * from './devOptions';
+export * from './fileReader';
+export declare function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server, }: {
+    pwd: string;
+    distDir: string;
+    apiDir: string;
+    sharedDir: string;
+    watchOptions?: WatchOptions;
+    server: ServerBase;
+}): Watcher;

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

@@ -0,0 +1,3 @@
+import { ServerRoute } from '@modern-js/types';
+import { ServerHookRunner } from '@modern-js/server-core';
+export declare const onRepack: (distDir: string, runner: ServerHookRunner, routes: ServerRoute[]) => void;

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

@@ -0,0 +1 @@
+export declare const debug: import("@modern-js/utils/compiled/debug").Debugger;

package/dist/types/index.d.ts

@@ -1,6 +1,2 @@
-import { DevServer as Server, DevServerForRsbuild as ServerForRsbuild } from './server';
-import type { ModernDevServerOptions, ModernDevServerOptionsNew } from './types';
-export { Server, ServerForRsbuild };
-export type { ModernDevServerOptions, ModernDevServerOptionsNew };
-declare const _default: (options: ModernDevServerOptions) => Promise<Server>;
-export default _default;
+export { createDevServer } from './createDevServer';
+export type { ModernDevServerOptions, InitProdMiddlewares, } from './createDevServer';

package/dist/types/types.d.ts

@@ -1,10 +1,8 @@
 /// <reference types="node" />
-/// <reference types="node/http" />
-/// <reference types="@modern-js/prod-server/src/type" />
 import type { IncomingMessage, ServerResponse } from 'http';
 import type { DevServerOptions, DevServerHttpsOptions, NextFunction } from '@modern-js/types';
-import type { ModernServerOptions } from '@modern-js/prod-server';
 import type { RsbuildInstance, RsbuildDevServer } from '@rsbuild/shared';
+import { ServerBase, ServerBaseOptions } from '@modern-js/server-core/base';
 export type { DevServerOptions, DevServerHttpsOptions };
 type Middleware = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => Promise<void>;
 export type DevMiddlewareAPI = Middleware & {
@@ -34,17 +32,12 @@ export type DevMiddlewareOptions = {
  */
 export type DevMiddleware = (options: DevMiddlewareOptions) => DevMiddlewareAPI;
 export type ExtraOptions = {
-    dev: boolean | Partial<DevServerOptions>;
-    devMiddleware?: DevMiddleware;
-    useSSRWorker?: boolean;
-};
-export type ModernDevServerOptions = ModernServerOptions & ExtraOptions;
-export type ExtraOptionsNew = {
     dev: Pick<DevServerOptions, 'watch' | 'https'> & {
         writeToDisk?: boolean | ((filename: string) => boolean);
     };
     useSSRWorker?: boolean;
     rsbuild: RsbuildInstance;
-    getMiddlewares: () => Pick<RsbuildDevServer, 'middlewares' | 'onHTTPUpgrade' | 'close'>;
+    getMiddlewares?: () => Pick<RsbuildDevServer, 'middlewares' | 'onHTTPUpgrade' | 'close'>;
 };
-export type ModernDevServerOptionsNew = ModernServerOptions & ExtraOptionsNew;
+export type ModernDevServerOptions<O extends ServerBaseOptions = ServerBaseOptions> = O & ExtraOptions;
+export type InitProdMiddlewares<O extends ServerBaseOptions = ServerBaseOptions> = (server: ServerBase, options: O) => Promise<ServerBase>;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.48.6",
+  "version": "2.49.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -42,20 +42,19 @@
     "@babel/core": "^7.23.2",
     "@babel/register": "^7.22.15",
     "@swc/helpers": "0.5.3",
+    "axios": "^1.6.0",
     "connect-history-api-fallback": "^2.0.0",
     "http-compression": "1.0.6",
     "minimatch": "^3.0.4",
     "path-to-regexp": "^6.2.0",
     "ws": "^8.13.0",
-    "axios": "^1.6.0",
-    "@modern-js/prod-server": "2.48.6",
-    "@modern-js/server-utils": "2.48.6",
-    "@modern-js/types": "2.48.6",
-    "@modern-js/utils": "2.48.6",
-    "@modern-js/runtime-utils": "2.48.6"
+    "@modern-js/runtime-utils": "2.49.0",
+    "@modern-js/types": "2.49.0",
+    "@modern-js/server-utils": "2.49.0",
+    "@modern-js/utils": "2.49.0"
   },
   "devDependencies": {
-    "@rsbuild/shared": "0.6.1",
+    "@rsbuild/shared": "0.6.3",
     "@types/connect-history-api-fallback": "^1.3.5",
     "@types/jest": "^29",
     "@types/minimatch": "^3.0.5",
@@ -68,9 +67,9 @@
     "typescript": "^5",
     "webpack": "^5.91.0",
     "websocket": "^1",
-    "@modern-js/server-core": "2.48.6",
-    "@scripts/build": "2.48.6",
-    "@scripts/jest-config": "2.48.6"
+    "@modern-js/server-core": "2.49.0",
+    "@scripts/build": "2.49.0",
+    "@scripts/jest-config": "2.49.0"
   },
   "peerDependencies": {
     "devcert": "^1.2.2",

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

@@ -1,61 +0,0 @@
-"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 createSocketUrl_exports = {};
-__export(createSocketUrl_exports, {
-  createSocketUrl: () => createSocketUrl,
-  formatURL: () => formatURL
-});
-module.exports = __toCommonJS(createSocketUrl_exports);
-var import_constants = require("@modern-js/utils/universal/constants");
-function createSocketUrl(resourceQuery) {
-  const searchParams = resourceQuery.substr(1).split("&");
-  const options = {};
-  for (const pair of searchParams) {
-    const ary = pair.split("=");
-    options[ary[0]] = decodeURIComponent(ary[1]);
-  }
-  const currentLocation = self.location;
-  return getSocketUrl(options, currentLocation);
-}
-function formatURL({ port, protocol, hostname, pathname }) {
-  if (typeof URL !== "undefined") {
-    const url = new URL("http://localhost");
-    url.port = port;
-    url.hostname = hostname;
-    url.protocol = protocol;
-    url.pathname = pathname;
-    return url.toString();
-  }
-  const colon = protocol.indexOf(":") === -1 ? ":" : "";
-  return `${protocol}${colon}//${hostname}:${port}${pathname}`;
-}
-function getSocketUrl(urlParts, location) {
-  const { host, port, path, protocol } = urlParts;
-  return formatURL({
-    protocol: protocol || (location.protocol === "https:" ? "wss" : "ws"),
-    hostname: host || location.hostname,
-    port: port || location.port,
-    pathname: path || import_constants.HMR_SOCK_PATH
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createSocketUrl,
-  formatURL
-});