@modern-js/server 2.4.1-beta.0 → 2.5.0

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;

package/package.json

@@ -11,20 +11,19 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.4.1-beta.0",
+  "version": "2.5.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
-  "main": "./dist/js/node/index.js",
-  "module": "./dist/js/treeshaking/index.js",
-  "jsnext:modern": "./dist/js/modern/index.js",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
   "exports": {
     ".": {
       "node": {
         "jsnext:source": "./src/index.ts",
-        "import": "./dist/js/modern/index.js",
-        "require": "./dist/js/node/index.js"
+        "import": "./dist/esm-node/index.js",
+        "require": "./dist/cjs/index.js"
       },
-      "default": "./dist/js/treeshaking/index.js"
+      "default": "./dist/esm/index.js"
     }
   },
   "dependencies": {
@@ -34,10 +33,10 @@
     "minimatch": "^3.0.4",
     "path-to-regexp": "^6.2.0",
     "ws": "^8.2.0",
-    "@modern-js/prod-server": "2.4.1-beta.0",
-    "@modern-js/server-utils": "2.4.1-beta.0",
-    "@modern-js/types": "2.4.0",
-    "@modern-js/utils": "2.4.1-beta.0"
+    "@modern-js/prod-server": "2.5.0",
+    "@modern-js/server-utils": "2.5.0",
+    "@modern-js/types": "2.5.0",
+    "@modern-js/utils": "2.5.0"
   },
   "devDependencies": {
     "@types/connect-history-api-fallback": "^1.3.5",
@@ -52,9 +51,9 @@
     "typescript": "^4",
     "webpack": "^5.75.0",
     "websocket": "^1",
-    "@modern-js/server-core": "2.4.1-beta.0",
-    "@scripts/jest-config": "2.4.0",
-    "@scripts/build": "2.4.0"
+    "@modern-js/server-core": "2.5.0",
+    "@scripts/jest-config": "2.5.0",
+    "@scripts/build": "2.5.0"
   },
   "peerDependencies": {
     "devcert": "^1.0.0",

package/dist/js/modern/dev-tools/mock/getMockData.js

@@ -1,114 +0,0 @@
-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));
-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 { compatRequire } from "@modern-js/utils";
-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) => (context, next) => __async(void 0, null, function* () {
-  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"];
-const normalizeConfig = (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(__spreadProps(__spreadValues({}, meta), {
-      handler: createStaticDataHandler(meta.method, handler)
-    }));
-  } else {
-    acc.push(__spreadProps(__spreadValues({}, 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
-  };
-};
-var getMockData_default = (filepath) => {
-  const mockModule = compatRequire(filepath);
-  if (!mockModule) {
-    throw new Error(`Mock file ${filepath} parsed failed!`);
-  }
-  const data = normalizeConfig(mockModule);
-  return data;
-};
-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
-};