@modern-js/server 2.4.0 → 2.5.0

package/dist/{js/modern → esm-node}/dev-tools/dev-middleware/index.js

@@ -1,39 +1,3 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 import { EventEmitter } from "events";
 import SocketServer from "./socket-server";
 const noop = () => {
@@ -59,11 +23,11 @@ class DevMiddleware extends EventEmitter {
     app.on("listening", () => {
       this.socketServer.prepare(app);
     });
-    app.on("close", () => __async(this, null, function* () {
+    app.on("close", async () => {
       var _a;
       (_a = this.middleware) == null ? void 0 : _a.close(noop);
       this.socketServer.close();
-    }));
+    });
   }
   sockWrite(type, data) {
     this.socketServer.sockWrite(type, data);
@@ -80,12 +44,13 @@ class DevMiddleware extends EventEmitter {
       }
     };
     const enableHMR = this.devOptions.hot || this.devOptions.liveReload;
-    const middleware = devMiddleware(__spreadValues({
+    const middleware = devMiddleware({
       headers: devOptions.headers,
       stats: false,
       callbacks,
-      hmrClientPath: enableHMR ? getHMRClientPath(devOptions.client) : void 0
-    }, devOptions.devMiddleware));
+      hmrClientPath: enableHMR ? getHMRClientPath(devOptions.client) : void 0,
+      ...devOptions.devMiddleware
+    });
     return middleware;
   }
 }

package/dist/{js/modern → esm-node}/dev-tools/https/index.js

@@ -1,32 +1,12 @@
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 import { chalk, getPackageManager, logger } from "@modern-js/utils";
-const genHttpsOptions = (userOptions, pwd) => __async(void 0, null, function* () {
+const genHttpsOptions = async (userOptions, pwd) => {
   const httpsOptions = typeof userOptions === "boolean" ? {} : userOptions;
   if (!httpsOptions.key || !httpsOptions.cert) {
     let devcertPath;
     try {
       devcertPath = require.resolve("devcert", { paths: [pwd, __dirname] });
     } catch (err) {
-      const packageManager = yield getPackageManager(pwd);
+      const packageManager = await getPackageManager(pwd);
       const command = chalk.yellow.bold(
         `${packageManager} install devcert@1.2.2 -D`
       );
@@ -39,11 +19,11 @@ const genHttpsOptions = (userOptions, pwd) => __async(void 0, null, function* ()
       throw new Error('[https] "devcert" is not found.');
     }
     const devcert = require(devcertPath);
-    const selfsign = yield devcert.certificateFor(["localhost"]);
+    const selfsign = await devcert.certificateFor(["localhost"]);
     return selfsign;
   }
   return httpsOptions;
-});
+};
 export {
   genHttpsOptions
 };

package/dist/esm-node/dev-tools/mock/getMockData.js

@@ -0,0 +1,68 @@
+import { match } from "path-to-regexp";
+const VALID_METHODS = ["get", "post", "put", "delete", "patch"];
+const BODY_PARSED_METHODS = ["post", "put", "delete", "patch"];
+const createFunctionDataHandler = (method, handler) => async (context, next) => {
+  const { req, res } = context;
+  return handler(req, res, next);
+};
+const createStaticDataHandler = (method, handler) => (context) => {
+  const { res } = context;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(handler));
+};
+const allowTypes = ["object", "function"];
+var getMockData_default = (mockConfig) => Object.keys(mockConfig).reduce((acc, key) => {
+  const handler = mockConfig[key];
+  const type = typeof handler;
+  if (!allowTypes.includes(type)) {
+    throw new Error(
+      `mock value of ${key} should be object or function, but got ${type}`
+    );
+  }
+  const meta = parseKey(key);
+  if (type === "object") {
+    acc.push({
+      ...meta,
+      handler: createStaticDataHandler(meta.method, handler)
+    });
+  } else {
+    acc.push({
+      ...meta,
+      handler: createFunctionDataHandler(meta.method, handler)
+    });
+  }
+  return acc;
+}, []);
+const _blank = " ";
+const parseKey = (key) => {
+  const splitted = key.split(_blank).filter(Boolean);
+  if (splitted.length > 1) {
+    const [method, pathname] = splitted;
+    return {
+      method: method.toLowerCase(),
+      path: pathname
+    };
+  }
+  return {
+    method: "get",
+    path: key
+  };
+};
+const getMatched = (context, mockApiList) => {
+  const { path: targetPathname, method: targetMethod } = context;
+  const matched = mockApiList.find((mockApi) => {
+    const { method, path: pathname } = mockApi;
+    if (method.toLowerCase() === targetMethod.toLowerCase()) {
+      return match(pathname, {
+        encode: encodeURI,
+        decode: decodeURIComponent
+      })(targetPathname);
+    }
+    return false;
+  });
+  return matched;
+};
+export {
+  getMockData_default as default,
+  getMatched
+};

package/dist/{js/modern → esm-node}/dev-tools/mock/index.js

@@ -1,25 +1,5 @@
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 import path from "path";
-import { fs } from "@modern-js/utils";
+import { compatRequire, fs } from "@modern-js/utils";
 import { AGGRED_DIR } from "@modern-js/prod-server";
 import getMockData, { getMatched } from "./getMockData";
 const createMockHandler = ({ pwd }) => {
@@ -35,11 +15,27 @@ const createMockHandler = ({ pwd }) => {
   if (!filepath) {
     return null;
   }
-  const apiList = getMockData(filepath);
+  const {
+    default: mockModule,
+    config
+  } = compatRequire(filepath, false);
+  if ((config == null ? void 0 : config.enable) === false) {
+    return null;
+  }
+  if (!mockModule) {
+    throw new Error(`Mock file ${filepath} parsed failed!`);
+  }
+  const apiList = getMockData(mockModule);
   if (!apiList || apiList.length === 0) {
     return null;
   }
-  return (context, next) => __async(void 0, null, function* () {
+  return async (context, next) => {
+    if (typeof (config == null ? void 0 : config.enable) === "function") {
+      const enableMock = config.enable(context.req, context.res);
+      if (!enableMock) {
+        return next();
+      }
+    }
     const { res } = context;
     const matched = getMatched(context, apiList);
     if (!matched) {
@@ -47,7 +43,7 @@ const createMockHandler = ({ pwd }) => {
     }
     res.setHeader("Access-Control-Allow-Origin", "*");
     return matched.handler(context, next);
-  });
+  };
 };
 export {
   createMockHandler

package/dist/{js/modern → esm-node}/dev-tools/register/index.js

@@ -1,22 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import path from "path";
 import { resolveBabelConfig } from "@modern-js/server-utils";
 import { fs, getAliasConfig, createDebugger } from "@modern-js/utils";
@@ -58,9 +39,10 @@ const enableRegister = (projectRoot, config) => {
       if (typeof tsPath === "string") {
         tsPath = [tsPath];
       }
-      return __spreadProps(__spreadValues({}, o), {
+      return {
+        ...o,
         [`${key}`]: tsPath
-      });
+      };
     }, {});
     tsConfigPaths.register({
       baseUrl: absoluteBaseUrl || "./",
@@ -68,6 +50,7 @@ const enableRegister = (projectRoot, config) => {
     });
     tsNode.register({
       project: tsconfigPath,
+      scope: true,
       files: true,
       transpileOnly: true,
       ignore: ["(?:^|/)node_modules/", `(?:^|/)${distPath}/`]
@@ -76,19 +59,21 @@ const enableRegister = (projectRoot, config) => {
     debug("use @babel/register");
     const babelConfig = resolveBabelConfig(
       projectRoot,
-      __spreadProps(__spreadValues({}, config.source), {
+      {
+        ...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")(__spreadProps(__spreadValues({}, babelConfig), {
+    return require("@babel/register")({
+      ...babelConfig,
       only: [
         function(filePath) {
           if (filePath.includes(`node_modules${path.sep}.modern-js`)) {
@@ -103,7 +88,7 @@ const enableRegister = (projectRoot, config) => {
       babelrc: false,
       configFile: false,
       root: projectRoot
-    }));
+    });
   }
 };
 export {

package/dist/{js/modern → esm-node}/dev-tools/watcher/index.js

@@ -1,19 +1,3 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
 import path from "path";
 import { fs, chokidar } from "@modern-js/utils";
 import { DependencyTree } from "./dependency-tree";
@@ -33,7 +17,9 @@ const getWatchedFiles = (watcher) => {
   return files;
 };
 const mergeWatchOptions = (options) => {
-  const watchOptions = __spreadValues({}, options);
+  const watchOptions = {
+    ...options
+  };
   if (watchOptions) {
     const { ignored } = watchOptions;
     const finalIgnored = ignored ? [
@@ -44,7 +30,10 @@ const mergeWatchOptions = (options) => {
       watchOptions.ignored = finalIgnored;
     }
   }
-  const finalWatchOptions = __spreadValues(__spreadValues({}, defaultWatchOptions), watchOptions);
+  const finalWatchOptions = {
+    ...defaultWatchOptions,
+    ...watchOptions
+  };
   return finalWatchOptions;
 };
 class Watcher {

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/types/dev-tools/mock/getMockData.d.ts

@@ -12,7 +12,7 @@ export type MockApi = {
 declare const createFunctionDataHandler: (method: string, handler: (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void) => (context: ModernServerContext, next: NextFunction) => Promise<void>;
 declare const createStaticDataHandler: (method: string, handler: Record<string, any>) => (context: ModernServerContext) => void;
 
-declare const _default: (filepath: string) => MockApi[];
+declare const _default: (mockConfig: MockConfig) => MockApi[];
 
 export default _default;
 export declare const getMatched: (context: ModernServerContext, mockApiList: MockApi[]) => MockApi | undefined;