@modern-js/server 2.4.1-beta.0 → 2.5.1-alpha.0

package/dist/esm-node/dev-tools/register/index.js

@@ -0,0 +1,96 @@
+import path from "path";
+import { resolveBabelConfig } from "@modern-js/server-utils";
+import { fs, getAliasConfig, createDebugger } from "@modern-js/utils";
+const debug = createDebugger("server");
+const checkDep = (depName, paths) => {
+  let packagePath = "";
+  try {
+    packagePath = require.resolve(depName, {
+      paths
+    });
+  } catch (error) {
+  }
+  return Boolean(packagePath);
+};
+const enableRegister = (projectRoot, config) => {
+  var _a, _b, _c;
+  const registerDirs = ["./api", "./server", "./config/mock", "./shared"];
+  const TS_CONFIG_FILENAME = `tsconfig.json`;
+  const tsconfigPath = path.resolve(projectRoot, TS_CONFIG_FILENAME);
+  const isTsProject = fs.existsSync(tsconfigPath);
+  const existTsNode = checkDep("ts-node", [projectRoot]);
+  const existTsConfigPaths = checkDep("tsconfig-paths", [projectRoot]);
+  if (isTsProject && existTsNode && existTsConfigPaths) {
+    debug("use ts-node");
+    const distPath = ((_a = config.output.distPath) == null ? void 0 : _a.root) || "dist";
+    const tsNode = require("ts-node");
+    const tsConfigPaths = require("tsconfig-paths");
+    const { alias } = config.source;
+    const aliasConfig = getAliasConfig(alias, {
+      appDirectory: projectRoot,
+      tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = "./" } = aliasConfig;
+    const tsPaths = Object.keys(paths).reduce((o, key) => {
+      let tsPath = paths[key];
+      if (typeof tsPath === "string" && path.isAbsolute(tsPath)) {
+        tsPath = path.relative(absoluteBaseUrl, tsPath);
+      }
+      if (typeof tsPath === "string") {
+        tsPath = [tsPath];
+      }
+      return {
+        ...o,
+        [`${key}`]: tsPath
+      };
+    }, {});
+    tsConfigPaths.register({
+      baseUrl: absoluteBaseUrl || "./",
+      paths: tsPaths
+    });
+    tsNode.register({
+      project: tsconfigPath,
+      scope: true,
+      files: true,
+      transpileOnly: true,
+      ignore: ["(?:^|/)node_modules/", `(?:^|/)${distPath}/`]
+    });
+  } else {
+    debug("use @babel/register");
+    const babelConfig = resolveBabelConfig(
+      projectRoot,
+      {
+        ...config.source,
+        babelConfig: (_b = config.tools) == null ? void 0 : _b.babel,
+        server: {
+          compiler: (_c = config.server) == null ? void 0 : _c.compiler
+        }
+      },
+      {
+        tsconfigPath,
+        syntax: "es6+",
+        type: "commonjs"
+      }
+    );
+    return require("@babel/register")({
+      ...babelConfig,
+      only: [
+        function(filePath) {
+          if (filePath.includes(`node_modules${path.sep}.modern-js`)) {
+            return true;
+          }
+          return registerDirs.some(
+            (registerDir) => filePath.startsWith(path.join(projectRoot, registerDir))
+          );
+        }
+      ],
+      extensions: [".js", ".ts"],
+      babelrc: false,
+      configFile: false,
+      root: projectRoot
+    });
+  }
+};
+export {
+  enableRegister
+};

package/dist/esm-node/dev-tools/watcher/dependency-tree.js

@@ -0,0 +1,59 @@
+import minimatch from "minimatch";
+const defaultIgnores = [
+  "**/bower_components/**",
+  "**/coverage/**",
+  "**/node_modules/**",
+  "**/.*/**",
+  "**/*.d.ts",
+  "**/*.log"
+];
+class DependencyTree {
+  constructor() {
+    this.tree = /* @__PURE__ */ new Map();
+    this.ignore = [...defaultIgnores];
+  }
+  getNode(path) {
+    return this.tree.get(path);
+  }
+  update(cache) {
+    this.tree.clear();
+    Object.keys(cache).forEach((path) => {
+      if (!this.shouldIgnore(path)) {
+        const module = cache[path];
+        this.tree.set(module.filename, {
+          module,
+          parent: /* @__PURE__ */ new Set(),
+          children: /* @__PURE__ */ new Set()
+        });
+      }
+    });
+    for (const treeNode of this.tree.values()) {
+      const { parent } = treeNode.module;
+      const { children } = treeNode.module;
+      if (parent && !this.shouldIgnore(parent.filename)) {
+        const parentTreeNode = this.tree.get(parent.filename);
+        if (parentTreeNode) {
+          treeNode.parent.add(parentTreeNode);
+        }
+      }
+      children.forEach((child) => {
+        if (!this.shouldIgnore(child.filename)) {
+          const childTreeNode = this.tree.get(child.filename);
+          if (childTreeNode) {
+            treeNode.children.add(childTreeNode);
+            childTreeNode.parent.add(treeNode);
+          }
+        }
+      });
+    }
+  }
+  shouldIgnore(path) {
+    return !path || Boolean(
+      this.ignore.find((rule) => minimatch.match([path], rule).length > 0)
+    );
+  }
+}
+export {
+  DependencyTree,
+  defaultIgnores
+};

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

@@ -0,0 +1,95 @@
+import path from "path";
+import { fs, chokidar } from "@modern-js/utils";
+import { DependencyTree } from "./dependency-tree";
+import { StatsCache } from "./stats-cache";
+const defaultWatchOptions = {
+  ignoreInitial: true,
+  ignored: /api\/typings\/.*/
+};
+const getWatchedFiles = (watcher) => {
+  const watched = watcher.getWatched();
+  const files = [];
+  Object.keys(watched).forEach((dir) => {
+    watched[dir].forEach((fileName) => {
+      files.push(path.join(dir, fileName));
+    });
+  });
+  return files;
+};
+const mergeWatchOptions = (options) => {
+  const watchOptions = {
+    ...options
+  };
+  if (watchOptions) {
+    const { ignored } = watchOptions;
+    const finalIgnored = ignored ? [
+      defaultWatchOptions.ignored,
+      ...Array.isArray(ignored) ? ignored : [ignored]
+    ] : ignored;
+    if (finalIgnored) {
+      watchOptions.ignored = finalIgnored;
+    }
+  }
+  const finalWatchOptions = {
+    ...defaultWatchOptions,
+    ...watchOptions
+  };
+  return finalWatchOptions;
+};
+class Watcher {
+  constructor() {
+    this.dependencyTree = null;
+  }
+  listen(files, options, callback) {
+    const watched = files.filter(Boolean);
+    const filenames = watched.map((filename) => filename.replace(/\\/g, "/"));
+    const cache = new StatsCache();
+    const watcher = chokidar.watch(filenames, options);
+    watcher.on("ready", () => {
+      cache.add(getWatchedFiles(watcher));
+    });
+    watcher.on("change", (changed) => {
+      if (!fs.existsSync(changed) || cache.isDiff(changed)) {
+        cache.refresh(changed);
+        callback(changed, "change");
+      }
+    });
+    watcher.on("add", (changed) => {
+      if (!cache.has(changed)) {
+        cache.add([changed]);
+        callback(changed, "add");
+      }
+    });
+    watcher.on("unlink", (changed) => {
+      cache.del(changed);
+      callback(changed, "unlink");
+    });
+    this.watcher = watcher;
+  }
+  createDepTree() {
+    this.dependencyTree = new DependencyTree();
+  }
+  updateDepTree() {
+    var _a;
+    (_a = this.dependencyTree) == null ? void 0 : _a.update(require.cache);
+  }
+  cleanDepCache(filepath) {
+    var _a;
+    const node = (_a = this.dependencyTree) == null ? void 0 : _a.getNode(filepath);
+    if (node && require.cache[filepath]) {
+      delete require.cache[filepath];
+      for (const parentNode of node.parent.values()) {
+        this.cleanDepCache(parentNode.module.filename);
+      }
+    }
+  }
+  close() {
+    return this.watcher.close();
+  }
+}
+export {
+  Watcher as default,
+  defaultWatchOptions,
+  getWatchedFiles,
+  mergeWatchOptions
+};

package/dist/esm-node/dev-tools/watcher/stats-cache.js

@@ -0,0 +1,58 @@
+import fs from "fs";
+import crypto from "crypto";
+class StatsCache {
+  constructor() {
+    this.cachedHash = {};
+    this.cachedSize = {};
+  }
+  add(files) {
+    const { cachedHash, cachedSize } = this;
+    for (const filename of files) {
+      if (fs.existsSync(filename)) {
+        const stats = fs.statSync(filename);
+        if (stats.isFile() && !cachedHash[filename]) {
+          cachedHash[filename] = this.hash(stats, filename);
+          cachedSize[filename] = stats.size;
+        }
+      }
+    }
+  }
+  refresh(filename) {
+    const { cachedHash, cachedSize } = this;
+    if (fs.existsSync(filename)) {
+      const stats = fs.statSync(filename);
+      if (stats.isFile()) {
+        cachedHash[filename] = this.hash(stats, filename);
+        cachedSize[filename] = stats.size;
+      }
+    }
+  }
+  del(filename) {
+    if (this.cachedHash[filename]) {
+      delete this.cachedHash[filename];
+      delete this.cachedSize[filename];
+    }
+  }
+  isDiff(filename) {
+    const { cachedHash, cachedSize } = this;
+    const stats = fs.statSync(filename);
+    const hash = cachedHash[filename];
+    const size = cachedSize[filename];
+    if (stats.size !== size) {
+      return true;
+    }
+    if (this.hash(stats, filename) !== hash) {
+      return true;
+    }
+    return false;
+  }
+  has(filename) {
+    return Boolean(this.cachedHash[filename]);
+  }
+  hash(stats, filename) {
+    return crypto.createHash("md5").update(fs.readFileSync(filename)).digest("hex");
+  }
+}
+export {
+  StatsCache
+};

package/dist/esm-node/index.js

@@ -0,0 +1,12 @@
+import { DevServer as Server } 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();
+};
+export {
+  Server,
+  src_default as default
+};

package/dist/esm-node/server/dev-server.js

@@ -0,0 +1,247 @@
+import { createServer } from "http";
+import path from "path";
+import { createServer as createHttpsServer } from "https";
+import {
+  API_DIR,
+  SERVER_BUNDLE_DIRECTORY,
+  SERVER_DIR,
+  SHARED_DIR
+} from "@modern-js/utils";
+import {
+  createProxyHandler,
+  ModernServer,
+  AGGRED_DIR
+} from "@modern-js/prod-server";
+import { LOADABLE_STATS_FILE } from "@modern-js/utils/constants";
+import { getDefaultDevOptions } from "../constants";
+import { createMockHandler } from "../dev-tools/mock";
+import { enableRegister } from "../dev-tools/register";
+import Watcher, { mergeWatchOptions } from "../dev-tools/watcher";
+import DevMiddleware from "../dev-tools/dev-middleware";
+class ModernDevServer extends ModernServer {
+  constructor(options) {
+    super(options);
+    this.mockHandler = null;
+    this.workDir = this.pwd;
+    this.dev = this.getDevOptions(options);
+    this.devMiddleware = new DevMiddleware({
+      dev: this.dev,
+      devMiddleware: options.devMiddleware
+    });
+    enableRegister(this.pwd, this.conf);
+  }
+  getDevOptions(options) {
+    const devOptions = typeof options.dev === "boolean" ? {} : options.dev;
+    const defaultOptions = getDefaultDevOptions();
+    return {
+      ...defaultOptions,
+      ...devOptions,
+      client: {
+        ...defaultOptions.client,
+        ...devOptions == null ? void 0 : devOptions.client
+      }
+    };
+  }
+  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 };
+  }
+  async onInit(runner, app) {
+    this.runner = runner;
+    const { dev } = this;
+    const { befores, afters } = this.applySetupMiddlewares();
+    const beforeHandlers = await this.setupBeforeDevMiddleware();
+    this.addMiddlewareHandler([...beforeHandlers, ...befores]);
+    await this.applyDefaultMiddlewares(app);
+    const afterHandlers = await this.setupAfterDevMiddleware();
+    this.addMiddlewareHandler([...afters, ...afterHandlers]);
+    await super.onInit(runner, app);
+    if (dev.watch) {
+      this.startWatcher();
+      app.on("close", async () => {
+        var _a;
+        await ((_a = this.watcher) == null ? void 0 : _a.close());
+      });
+    }
+  }
+  async applyDefaultMiddlewares(app) {
+    const { pwd, dev, devMiddleware } = this;
+    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 = createMockHandler({ pwd });
+    this.addHandler((ctx, next) => {
+      if (this.mockHandler) {
+        this.mockHandler(ctx, next);
+      } else {
+        next();
+      }
+    });
+    const proxyHandlers = createProxyHandler(dev.proxy);
+    if (proxyHandlers) {
+      proxyHandlers.forEach((handler) => {
+        this.addHandler(handler);
+      });
+    }
+    devMiddleware.init(app);
+    devMiddleware.on("change", (stats) => {
+      if (stats.toJson({ all: false }).name === "client") {
+        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 import("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();
+    this.reader.updateFile();
+    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 createHttpsServer(httpsOptions, handler);
+    } else {
+      return createServer(handler);
+    }
+  }
+  warmupSSRBundle() {
+  }
+  onServerChange({
+    filepath,
+    event
+  }) {
+    const { pwd } = this;
+    const { mock } = AGGRED_DIR;
+    const mockPath = path.normalize(path.join(pwd, mock));
+    this.runner.reset();
+    if (filepath.startsWith(mockPath)) {
+      this.mockHandler = createMockHandler({ pwd });
+    } else {
+      try {
+        const success = this.runner.onApiChange([
+          { filename: filepath, event }
+        ]);
+        if (success !== true) {
+          super.onServerChange({ filepath });
+        }
+      } catch (e) {
+        this.logger.error(e);
+      }
+    }
+  }
+  createContext(req, res) {
+    return super.createContext(req, res, { etag: true });
+  }
+  async setupBeforeDevMiddleware() {
+    const { runner, conf, dev } = this;
+    const setupMids = dev.before || [];
+    const pluginMids = await runner.beforeDevServer(conf);
+    return [...setupMids, ...pluginMids].flat();
+  }
+  async setupAfterDevMiddleware() {
+    const { runner, conf, dev } = this;
+    const setupMids = dev.after || [];
+    const pluginMids = await runner.afterDevServer(conf);
+    return [...pluginMids, ...setupMids].flat();
+  }
+  cleanSSRCache() {
+    const { distDir } = this;
+    const bundles = this.router.getBundles();
+    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];
+    }
+  }
+  startWatcher() {
+    var _a;
+    const { pwd, distDir } = this;
+    const { mock } = AGGRED_DIR;
+    const defaultWatched = [
+      `${mock}/**/*`,
+      `${SERVER_DIR}/**/*`,
+      `${API_DIR}/**`,
+      `${SHARED_DIR}/**/*`,
+      `${distDir}/${SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
+    ];
+    const watchOptions = mergeWatchOptions((_a = this.conf.server) == null ? void 0 : _a.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, watchOptions, (filepath, event) => {
+      watcher.updateDepTree();
+      watcher.cleanDepCache(filepath);
+      this.onServerChange({
+        filepath,
+        event
+      });
+    });
+    this.watcher = watcher;
+  }
+}
+export {
+  ModernDevServer
+};

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

@@ -0,0 +1,16 @@
+import { Server } from "@modern-js/prod-server";
+import { ModernDevServer } from "./dev-server";
+const createDevServer = (options) => {
+  return new ModernDevServer(options);
+};
+class DevServer extends Server {
+  constructor(options) {
+    super(options);
+    if (options.dev) {
+      this.serverImpl = createDevServer;
+    }
+  }
+}
+export {
+  DevServer
+};

package/dist/js/modern/dev-tools/dev-middleware/hmr-client/index.js

@@ -10,14 +10,11 @@ var require_hmr_client = __commonJS({
     const hadRuntimeError = false;
     const socketUrl = createSocketUrl(__resourceQuery);
     const connection = new WebSocket(socketUrl);
-    connection.onopen = function() {
-      if (typeof console !== "undefined" && typeof console.debug === "function") {
-        console.debug("[HMR] connected.");
-      }
-    };
     connection.onclose = function() {
       if (typeof console !== "undefined" && typeof console.info === "function") {
-        console.debug("[HMR] disconnected. Refresh the page if necessary.");
+        console.info(
+          "The development server has disconnected.\nRefresh the page if necessary."
+        );
       }
     };
     let isFirstCompilation = true;

package/dist/js/node/dev-tools/dev-middleware/hmr-client/index.js

@@ -22,14 +22,11 @@ var import_createSocketUrl = require("./createSocketUrl");
 const hadRuntimeError = false;
 const socketUrl = (0, import_createSocketUrl.createSocketUrl)(__resourceQuery);
 const connection = new WebSocket(socketUrl);
-connection.onopen = function() {
-  if (typeof console !== "undefined" && typeof console.debug === "function") {
-    console.debug("[HMR] connected.");
-  }
-};
 connection.onclose = function() {
   if (typeof console !== "undefined" && typeof console.info === "function") {
-    console.debug("[HMR] disconnected. Refresh the page if necessary.");
+    console.info(
+      "The development server has disconnected.\nRefresh the page if necessary."
+    );
   }
 };
 let isFirstCompilation = true;

package/dist/js/treeshaking/dev-tools/dev-middleware/hmr-client/index.js

@@ -95,14 +95,9 @@ var require_hmr_client = __commonJS({
         var hadRuntimeError = false;
         var socketUrl = createSocketUrl(__resourceQuery);
         var connection = new WebSocket(socketUrl);
-        connection.onopen = function() {
-            if (typeof console !== "undefined" && typeof console.debug === "function") {
-                console.debug("[HMR] connected.");
-            }
-        };
         connection.onclose = function() {
             if (typeof console !== "undefined" && typeof console.info === "function") {
-                console.debug("[HMR] disconnected. Refresh the page if necessary.");
+                console.info("The development server has disconnected.\nRefresh the page if necessary.");
             }
         };
         var isFirstCompilation = true;

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

@@ -275,9 +275,9 @@ var DevMiddleware = /*#__PURE__*/ function(EventEmitter) {
                 });
                 var _this1 = this;
                 app.on("close", /*#__PURE__*/ _asyncToGenerator(function() {
-                    var _this_middleware;
+                    var ref;
                     return __generator(this, function(_state) {
-                        (_this_middleware = _this1.middleware) === null || _this_middleware === void 0 ? void 0 : _this_middleware.close(noop);
+                        (ref = _this1.middleware) === null || ref === void 0 ? void 0 : ref.close(noop);
                         _this1.socketServer.close();
                         return [
                             2

package/dist/js/treeshaking/dev-tools/dev-middleware/socket-server.js

@@ -49,11 +49,11 @@ var SocketServer = /*#__PURE__*/ function() {
             key: "prepare",
             value: function prepare(app) {
                 var _this = this;
-                var _this_options_client;
+                var ref;
                 this.app = app;
                 this.wsServer = new ws.Server({
                     noServer: true,
-                    path: (_this_options_client = this.options.client) === null || _this_options_client === void 0 ? void 0 : _this_options_client.path
+                    path: (ref = this.options.client) === null || ref === void 0 ? void 0 : ref.path
                 });
                 this.app.on("upgrade", function(req, sock, head) {
                     if (!_this.wsServer.shouldHandle(req)) {