@modern-js/prod-server 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/js/treeshaking/libs/route/index.js

@@ -0,0 +1,94 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { RouteMatcher } from "./matcher";
+export var RouteMatchManager = /*#__PURE__*/function () {
+  function RouteMatchManager() {
+    _classCallCheck(this, RouteMatchManager);
+    _defineProperty(this, "matchers", void 0);
+    _defineProperty(this, "specs", []);
+    this.matchers = [];
+  }
+
+  // get all routes matches pathname
+  _createClass(RouteMatchManager, [{
+    key: "filter",
+    value: function filter(pathname) {
+      return this.matchers.reduce(function (matches, matcher) {
+        if (matcher.matchUrlPath(pathname)) {
+          matches.push(matcher);
+        }
+        return matches;
+      }, []);
+    }
+
+    // get best match from a set of matches
+  }, {
+    key: "best",
+    value: function best(pathname, matches) {
+      var best;
+      var matchedLen = 0;
+      var _iterator = _createForOfIteratorHelper(matches),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var match = _step.value;
+          var len = match.matchLength(pathname);
+          if (len === null) {
+            continue;
+          }
+          if (len > matchedLen) {
+            best = match;
+            matchedLen = len;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return best;
+    }
+
+    // reset routes matcher
+  }, {
+    key: "reset",
+    value: function reset(specs) {
+      this.specs = specs;
+      var matchers = specs.reduce(function (ms, spec) {
+        ms.push(new RouteMatcher(spec));
+        return ms;
+      }, []);
+      this.matchers = matchers;
+    }
+
+    // get best match from all matcher in manager
+  }, {
+    key: "match",
+    value: function match(pathname) {
+      var matches = this.filter(pathname);
+      var best = this.best(pathname, matches);
+      return best;
+    }
+  }, {
+    key: "matchEntry",
+    value: function matchEntry(entryname) {
+      return this.matchers.find(function (matcher) {
+        return matcher.matchEntry(entryname);
+      });
+    }
+  }, {
+    key: "getBundles",
+    value: function getBundles() {
+      var bundles = this.specs.filter(function (route) {
+        return route.isSSR;
+      }).map(function (route) {
+        return route.bundle;
+      });
+      return bundles;
+    }
+  }]);
+  return RouteMatchManager;
+}();
+export { RouteMatcher };

package/dist/js/treeshaking/libs/route/matcher.js

@@ -0,0 +1,113 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { match, pathToRegexp, compile } from 'path-to-regexp';
+import { ModernRoute } from "./route";
+
+// avoid import @modern-js/utils
+var removeTailSlash = function removeTailSlash(s) {
+  return s.replace(/\/+$/, '');
+};
+var toPath = function toPath(reg, params) {
+  var fn = compile(reg, {
+    encode: encodeURIComponent
+  });
+  return fn(params);
+};
+
+// eslint-disable-next-line no-useless-escape
+var regCharsDetector = /[^a-zA-Z\-_0-9\/\.]/;
+export var RouteMatcher = /*#__PURE__*/function () {
+  function RouteMatcher(spec) {
+    _classCallCheck(this, RouteMatcher);
+    _defineProperty(this, "spec", void 0);
+    _defineProperty(this, "urlPath", '');
+    _defineProperty(this, "urlMatcher", void 0);
+    _defineProperty(this, "urlReg", void 0);
+    this.spec = spec;
+    this.setupUrlPath();
+  }
+
+  // generate modern route object
+  _createClass(RouteMatcher, [{
+    key: "generate",
+    value: function generate(url) {
+      var route = new ModernRoute(this.spec);
+      if (this.urlPath) {
+        var params = this.parseURLParams(url);
+        route.urlPath = toPath(route.urlPath, params);
+        route.params = params;
+      }
+      return route;
+    }
+  }, {
+    key: "parseURLParams",
+    value: function parseURLParams(pathname) {
+      if (!this.urlMatcher) {
+        return {};
+      } else {
+        var matchResult = this.urlMatcher(pathname);
+        return matchResult.params;
+      }
+    }
+
+    // get match url length
+  }, {
+    key: "matchLength",
+    value: function matchLength(pathname) {
+      if (!this.urlReg) {
+        return this.urlPath.length;
+      } else {
+        var _result$;
+        var result = this.urlReg.exec(pathname);
+        return (result === null || result === void 0 ? void 0 : (_result$ = result[0]) === null || _result$ === void 0 ? void 0 : _result$.length) || null;
+      }
+    }
+
+    // if match url path
+  }, {
+    key: "matchUrlPath",
+    value: function matchUrlPath(requestUrl) {
+      var urlWithoutSlash = requestUrl.endsWith('/') && requestUrl !== '/' ? requestUrl.slice(0, -1) : requestUrl;
+      if (urlWithoutSlash.endsWith('.html')) {
+        urlWithoutSlash = urlWithoutSlash.slice(0, -5);
+      }
+      if (this.urlMatcher) {
+        return Boolean(this.urlMatcher(urlWithoutSlash));
+      } else {
+        if (urlWithoutSlash.startsWith(this.urlPath)) {
+          // avoid /abcd match /a
+          if (this.urlPath !== '/' && urlWithoutSlash.length > this.urlPath.length && !urlWithoutSlash.startsWith("".concat(this.urlPath, "/"))) {
+            return false;
+          }
+          return true;
+        }
+        return false;
+      }
+    }
+  }, {
+    key: "matchEntry",
+    value: function matchEntry(entryName) {
+      return this.spec.entryName === entryName;
+    }
+
+    // compiler urlPath to regexp if necessary
+  }, {
+    key: "setupUrlPath",
+    value: function setupUrlPath() {
+      var urlPath = this.spec.urlPath;
+      this.urlPath = urlPath === '/' ? urlPath : removeTailSlash(urlPath);
+      var useReg = regCharsDetector.test(urlPath);
+      if (useReg) {
+        this.urlMatcher = match(urlPath, {
+          end: false,
+          decode: decodeURIComponent
+        });
+        this.urlReg = pathToRegexp(urlPath, [], {
+          end: false
+        });
+      }
+    }
+  }]);
+  return RouteMatcher;
+}();

package/dist/js/treeshaking/libs/route/route.js

@@ -0,0 +1,26 @@
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+export var ModernRoute = /*#__PURE__*/_createClass(function ModernRoute(routeSpec) {
+  var _routeSpec$enableMode;
+  _classCallCheck(this, ModernRoute);
+  _defineProperty(this, "entryName", void 0);
+  _defineProperty(this, "urlPath", void 0);
+  _defineProperty(this, "entryPath", void 0);
+  _defineProperty(this, "bundle", void 0);
+  _defineProperty(this, "isApi", void 0);
+  _defineProperty(this, "isSSR", void 0);
+  _defineProperty(this, "isSPA", void 0);
+  _defineProperty(this, "enableModernMode", void 0);
+  _defineProperty(this, "params", {});
+  _defineProperty(this, "responseHeaders", void 0);
+  this.entryName = routeSpec.entryName || '';
+  this.urlPath = routeSpec.urlPath;
+  this.entryPath = routeSpec.entryPath || '';
+  this.isSSR = routeSpec.isSSR || false;
+  this.isSPA = routeSpec.isSPA || false;
+  this.isApi = routeSpec.isApi || false;
+  this.bundle = routeSpec.bundle || '';
+  this.enableModernMode = (_routeSpec$enableMode = routeSpec.enableModernMode) !== null && _routeSpec$enableMode !== void 0 ? _routeSpec$enableMode : false;
+  this.responseHeaders = routeSpec.responseHeaders;
+});

package/dist/js/treeshaking/libs/serve-file.js

@@ -0,0 +1,75 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+// Todo 看看是不是能 fork 一份，即使命中也返回
+
+import serve from 'serve-static';
+import { isString, isRegExp } from '@modern-js/utils';
+import { useLocalPrefix } from "../utils";
+var removedPrefix = function removedPrefix(req, prefix) {
+  if (useLocalPrefix(prefix)) {
+    req.url = req.url.slice(prefix.length);
+    return function () {
+      req.url = prefix + req.url;
+    };
+  } else {
+    return function () {
+      // emptyy
+    };
+  }
+};
+export var faviconFallbackHandler = function faviconFallbackHandler(context, next) {
+  if (context.url === '/favicon.ico') {
+    context.res.statusCode = 204;
+    context.res.end();
+  } else {
+    next();
+  }
+};
+export var createStaticFileHandler = function createStaticFileHandler(rules) {
+  var output = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return (
+    /*#__PURE__*/
+    // eslint-disable-next-line consistent-return
+    function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(context, next) {
+        var requestUrl, req, res, _output$assetPrefix, assetPrefix, hitRule, resume;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                requestUrl = context.url, req = context.req, res = context.res;
+                _output$assetPrefix = output.assetPrefix, assetPrefix = _output$assetPrefix === void 0 ? '/' : _output$assetPrefix;
+                hitRule = rules.find(function (item) {
+                  if (isString(item.path) && requestUrl.startsWith(item.path)) {
+                    return true;
+                  } else if (isRegExp(item.path) && item.path.test(requestUrl)) {
+                    return true;
+                  }
+                  return false;
+                });
+                if (!hitRule) {
+                  _context.next = 8;
+                  break;
+                }
+                resume = removedPrefix(req, assetPrefix);
+                serve(hitRule.target)(req, res, function () {
+                  resume();
+                  next();
+                });
+                _context.next = 9;
+                break;
+              case 8:
+                return _context.abrupt("return", next());
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+      return function (_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }()
+  );
+};

package/dist/js/treeshaking/server/index.js

@@ -0,0 +1,339 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import path from 'path';
+import fs from 'fs';
+import { Logger, SHARED_DIR, OUTPUT_CONFIG_FILE, dotenv, dotenvExpand, INTERNAL_SERVER_PLUGINS } from '@modern-js/utils';
+import { serverManager, AppContext, ConfigContext, loadPlugins } from '@modern-js/server-core';
+import { metrics as defaultMetrics } from "../libs/metrics";
+import { loadConfig, getServerConfigPath, requireConfig } from "../libs/loadConfig";
+import { debug } from "../utils";
+import { createProdServer } from "./modern-server-split";
+export var Server = /*#__PURE__*/function () {
+  function Server(options) {
+    _classCallCheck(this, Server);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "serverImpl", createProdServer);
+    _defineProperty(this, "server", void 0);
+    _defineProperty(this, "app", void 0);
+    _defineProperty(this, "runner", void 0);
+    _defineProperty(this, "serverConfig", void 0);
+    options.logger = options.logger || new Logger({
+      level: 'warn'
+    });
+    options.metrics = options.metrics || defaultMetrics;
+    this.options = options;
+    this.serverConfig = {};
+  }
+
+  /**
+   * 初始化顺序
+   * - 读取 .env.{process.env.MODERN_ENV} 文件，加载环境变量
+   * - 获取 server runtime config
+   * - 设置 context
+   * - 创建 hooksRunner
+   * - 合并插件，内置插件和 serverConfig 中配置的插件
+   * - 执行 config hook
+   * - 获取最终的配置
+   * - 设置配置到 context
+   * - 初始化 server
+   * - 执行 prepare hook
+   * - 执行 server init
+   */
+  _createClass(Server, [{
+    key: "init",
+    value: function () {
+      var _init = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var options;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                options = this.options;
+                this.loadServerEnv(options);
+                this.initServerConfig(options);
+                _context.next = 5;
+                return this.injectContext(this.runner, options);
+              case 5:
+                _context.next = 7;
+                return this.createHookRunner();
+              case 7:
+                this.runner = _context.sent;
+                _context.next = 10;
+                return this.initConfig(this.runner, options);
+              case 10:
+                _context.next = 12;
+                return this.injectContext(this.runner, options);
+              case 12:
+                // initialize server
+                this.server = this.serverImpl(options);
+                _context.next = 15;
+                return this.runPrepareHook(this.runner);
+              case 15:
+                _context.next = 17;
+                return this.server.createHTTPServer(this.getRequestHandler());
+              case 17:
+                this.app = _context.sent;
+                _context.next = 20;
+                return this.server.onInit(this.runner, this.app);
+              case 20:
+                return _context.abrupt("return", this);
+              case 21:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+      function init() {
+        return _init.apply(this, arguments);
+      }
+      return init;
+    }()
+    /**
+     * Execute config hooks
+     * @param runner
+     * @param options
+     */
+  }, {
+    key: "runConfigHook",
+    value: function runConfigHook(runner, serverConfig) {
+      var newServerConfig = runner.config(serverConfig || {});
+      return newServerConfig;
+    }
+  }, {
+    key: "runPrepareHook",
+    value: function () {
+      var _runPrepareHook = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(runner) {
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                runner.prepare();
+              case 1:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+      function runPrepareHook(_x) {
+        return _runPrepareHook.apply(this, arguments);
+      }
+      return runPrepareHook;
+    }()
+  }, {
+    key: "initServerConfig",
+    value: function initServerConfig(options) {
+      var pwd = options.pwd,
+        serverConfigFile = options.serverConfigFile;
+      var distDirectory = path.join(pwd, options.config.output.path || 'dist');
+      var serverConfigPath = getServerConfigPath(distDirectory, serverConfigFile);
+      var serverConfig = requireConfig(serverConfigPath);
+      this.serverConfig = serverConfig;
+    }
+
+    /**
+     *
+     * merge cliConfig and serverConfig
+     */
+  }, {
+    key: "initConfig",
+    value: function () {
+      var _initConfig = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(runner, options) {
+        var pwd, config, serverConfig, finalServerConfig, resolvedConfigPath;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                pwd = options.pwd, config = options.config;
+                serverConfig = this.serverConfig;
+                finalServerConfig = this.runConfigHook(runner, serverConfig);
+                resolvedConfigPath = path.join(pwd, config.output.path || 'dist', OUTPUT_CONFIG_FILE);
+                options.config = loadConfig({
+                  cliConfig: config,
+                  serverConfig: finalServerConfig,
+                  resolvedConfigPath: resolvedConfigPath
+                });
+              case 5:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+      function initConfig(_x2, _x3) {
+        return _initConfig.apply(this, arguments);
+      }
+      return initConfig;
+    }()
+  }, {
+    key: "close",
+    value: function () {
+      var _close = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                this.app.close();
+              case 1:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+      function close() {
+        return _close.apply(this, arguments);
+      }
+      return close;
+    }()
+  }, {
+    key: "listen",
+    value: function listen(options, listener) {
+      var callback = function callback() {
+        listener === null || listener === void 0 ? void 0 : listener();
+      };
+      if (_typeof(options) === 'object') {
+        this.app.listen(options, callback);
+      } else {
+        this.app.listen(process.env.PORT || options || 8080, callback);
+      }
+    }
+  }, {
+    key: "getRequestHandler",
+    value: function getRequestHandler() {
+      var _this = this;
+      return function (req, res, next) {
+        var requestHandler = _this.server.getRequestHandler();
+        return requestHandler(req, res, next);
+      };
+    }
+  }, {
+    key: "render",
+    value: function () {
+      var _render = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(req, res, url) {
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                return _context5.abrupt("return", this.server.render(req, res, url));
+              case 1:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+      function render(_x4, _x5, _x6) {
+        return _render.apply(this, arguments);
+      }
+      return render;
+    }()
+  }, {
+    key: "createHookRunner",
+    value: function () {
+      var _createHookRunner = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+        var options, _options$internalPlug, internalPlugins, pwd, serverPlugins, loadedPlugins, hooksRunner;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                // clear server manager every create time
+                serverManager.clear();
+                options = this.options; // TODO: 确认下这里是不是可以不从 options 中取插件，而是从 config 中取和过滤
+                _options$internalPlug = options.internalPlugins, internalPlugins = _options$internalPlug === void 0 ? INTERNAL_SERVER_PLUGINS : _options$internalPlug, pwd = options.pwd;
+                serverPlugins = this.serverConfig.plugins || []; // server app context for serve plugin
+                loadedPlugins = loadPlugins(pwd, serverPlugins, {
+                  internalPlugins: internalPlugins
+                });
+                debug('plugins', loadedPlugins);
+                loadedPlugins.forEach(function (p) {
+                  serverManager.usePlugin(p);
+                });
+
+                // create runner
+                _context6.next = 9;
+                return serverManager.init();
+              case 9:
+                hooksRunner = _context6.sent;
+                return _context6.abrupt("return", hooksRunner);
+              case 11:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+      function createHookRunner() {
+        return _createHookRunner.apply(this, arguments);
+      }
+      return createHookRunner;
+    }()
+  }, {
+    key: "injectContext",
+    value: function () {
+      var _injectContext = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(runner, options) {
+        var appContext, config, pwd;
+        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                appContext = this.initAppContext();
+                config = options.config, pwd = options.pwd;
+                ConfigContext.set(config);
+                AppContext.set(_objectSpread(_objectSpread({}, appContext), {}, {
+                  distDirectory: path.join(pwd, config.output.path || 'dist')
+                }));
+              case 4:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this);
+      }));
+      function injectContext(_x7, _x8) {
+        return _injectContext.apply(this, arguments);
+      }
+      return injectContext;
+    }()
+  }, {
+    key: "initAppContext",
+    value: function initAppContext() {
+      var options = this.options;
+      var appDirectory = options.pwd,
+        _options$plugins = options.plugins,
+        plugins = _options$plugins === void 0 ? [] : _options$plugins,
+        config = options.config;
+      var serverPlugins = plugins.map(function (p) {
+        return {
+          server: p
+        };
+      });
+      return {
+        appDirectory: appDirectory,
+        distDirectory: path.join(appDirectory, config.output.path || 'dist'),
+        sharedDirectory: path.resolve(appDirectory, SHARED_DIR),
+        plugins: serverPlugins
+      };
+    }
+  }, {
+    key: "loadServerEnv",
+    value: function loadServerEnv(options) {
+      var appDirectory = options.pwd;
+      var serverEnv = process.env.MODERN_ENV;
+      var serverEnvPath = path.resolve(appDirectory, ".env.".concat(serverEnv));
+      if (serverEnv && fs.existsSync(serverEnvPath) && !fs.statSync(serverEnvPath).isDirectory()) {
+        var envConfig = dotenv.config({
+          path: serverEnvPath
+        });
+        dotenvExpand(envConfig);
+      }
+    }
+  }]);
+  return Server;
+}();