@modern-js/prod-server 1.0.1

package/dist/js/node/libs/render/ssr.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.render = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+var _mimeTypes = _interopRequireDefault(require("mime-types"));
+
+var _cookie = _interopRequireDefault(require("cookie"));
+
+var _cache = _interopRequireDefault(require("./cache"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const render = async (ctx, renderOptions, runner) => {
+  const {
+    urlPath,
+    bundle,
+    distDir,
+    template,
+    entryName,
+    staticGenerate
+  } = renderOptions;
+
+  const bundleJS = _path.default.join(distDir, bundle);
+
+  const context = {
+    request: {
+      baseUrl: urlPath,
+      params: ctx.params,
+      pathname: ctx.path,
+      host: ctx.host,
+      query: ctx.query,
+      url: ctx.href,
+      cookieMap: _cookie.default.parse(ctx.headers.cookie || ''),
+      headers: ctx.headers
+    },
+    redirection: {},
+    template,
+    entryName,
+    distDir,
+    staticGenerate,
+    logger: ctx.logger,
+    metrics: ctx.metrics
+  };
+  runner.extendSSRContext(context);
+
+  const serverRender = require(bundleJS)[_utils.SERVER_RENDER_FUNCTION_NAME];
+
+  const html = await (0, _cache.default)(serverRender, ctx)(context);
+  const {
+    url,
+    status = 302
+  } = context.redirection;
+
+  if (url) {
+    return {
+      content: url,
+      contentType: '',
+      statusCode: status,
+      redirect: true
+    };
+  }
+
+  return {
+    content: html,
+    contentType: _mimeTypes.default.contentType('html')
+  };
+};
+
+exports.render = render;

package/dist/js/node/libs/render/static.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleDirectory = handleDirectory;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _mimeTypes = _interopRequireDefault(require("mime-types"));
+
+var _reader = require("./reader");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+async function handleDirectory(ctx, entryPath, urlPath) {
+  const {
+    path: pathname
+  } = ctx;
+
+  const filepath = _path.default.join(entryPath, trimLeft(pathname, urlPath)); // If can match accurately, always return the one that matches accurately
+
+
+  let content = await (0, _reader.readFile)(filepath);
+
+  let contentType = _mimeTypes.default.contentType(_path.default.extname(filepath) || ''); // automatic addressing
+
+
+  if (!content) {
+    if (pathname.endsWith('/')) {
+      content = await (0, _reader.readFile)(`${filepath}index.html`);
+    } else if (!pathname.includes('.')) {
+      content = await (0, _reader.readFile)(`${filepath}.html`);
+
+      if (!content) {
+        content = await (0, _reader.readFile)(`${filepath}/index.html`);
+      }
+    } // set content-type as html
+
+
+    if (content) {
+      contentType = _mimeTypes.default.contentType('html');
+    }
+  }
+
+  if (!content) {
+    return null;
+  }
+
+  return {
+    content,
+    contentType: contentType || ''
+  };
+}
+
+const trimLeft = (str, prefix) => {
+  if (str.startsWith(prefix)) {
+    return str.substring(prefix.length);
+  }
+
+  return str;
+};

package/dist/js/node/libs/render/type.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RenderLevel = void 0;
+let RenderLevel;
+exports.RenderLevel = RenderLevel;
+
+(function (RenderLevel) {
+  RenderLevel[RenderLevel["CLIENT_RENDER"] = 0] = "CLIENT_RENDER";
+  RenderLevel[RenderLevel["SERVER_PREFETCH"] = 1] = "SERVER_PREFETCH";
+  RenderLevel[RenderLevel["SERVER_RENDER"] = 2] = "SERVER_RENDER";
+})(RenderLevel || (exports.RenderLevel = RenderLevel = {}));

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

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RouteMatchManager = void 0;
+Object.defineProperty(exports, "RouteMatcher", {
+  enumerable: true,
+  get: function () {
+    return _matcher.RouteMatcher;
+  }
+});
+
+var _matcher = require("./matcher");
+
+class RouteMatchManager {
+  constructor() {
+    this.matchers = void 0;
+    this.specs = [];
+    this.matchers = [];
+  } // get all routes matches pathname
+
+
+  filter(pathname) {
+    return this.matchers.reduce((matches, matcher) => {
+      if (matcher.matchUrlPath(pathname)) {
+        matches.push(matcher);
+      }
+
+      return matches;
+    }, []);
+  } // get best match from a set of matches
+
+
+  best(pathname, matches) {
+    let best;
+    let matchedLen = 0;
+
+    for (const match of matches) {
+      const len = match.matchLength(pathname);
+
+      if (len === null) {
+        continue;
+      }
+
+      if (len > matchedLen) {
+        best = match;
+        matchedLen = len;
+      }
+    }
+
+    return best;
+  } // reset routes matcher
+
+
+  reset(specs) {
+    this.specs = specs;
+    const matchers = specs.reduce((ms, spec) => {
+      ms.push(new _matcher.RouteMatcher(spec));
+      return ms;
+    }, []);
+    this.matchers = matchers;
+  } // get best match from all matcher in manager
+
+
+  match(pathname) {
+    const matches = this.filter(pathname);
+    const best = this.best(pathname, matches);
+    return best;
+  }
+
+  matchEntry(entryname) {
+    return this.matchers.find(matcher => matcher.matchEntry(entryname));
+  }
+
+  getBundles() {
+    const bundles = this.specs.filter(route => route.isSSR).map(route => route.bundle);
+    return bundles;
+  }
+
+}
+
+exports.RouteMatchManager = RouteMatchManager;

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

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RouteMatcher = void 0;
+
+var _utils = require("@modern-js/utils");
+
+var _pathToRegexp = require("path-to-regexp");
+
+var _utils2 = require("../../utils");
+
+var _route = require("./route");
+
+// eslint-disable-next-line no-useless-escape
+const regCharsDetector = /[^a-zA-Z\-_0-9\/\.]/;
+
+class RouteMatcher {
+  constructor(spec) {
+    this.spec = void 0;
+    this.urlPath = '';
+    this.urlMatcher = void 0;
+    this.urlReg = void 0;
+    this.spec = spec;
+    this.setupUrlPath();
+  } // generate modern route object
+
+
+  generate(url) {
+    const route = new _route.ModernRoute(this.spec);
+
+    if (this.urlPath) {
+      const params = this.parseURLParams(url);
+      route.urlPath = (0, _utils2.toPath)(route.urlPath, params);
+      route.params = params;
+    }
+
+    return route;
+  }
+
+  parseURLParams(pathname) {
+    if (!this.urlMatcher) {
+      return {};
+    } else {
+      const matchResult = this.urlMatcher(pathname);
+      return matchResult.params;
+    }
+  } // get match url length
+
+
+  matchLength(pathname) {
+    if (!this.urlReg) {
+      return this.urlPath.length;
+    } else {
+      var _result$;
+
+      const 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
+
+
+  matchUrlPath(requestUrl) {
+    const urlWithoutSlash = requestUrl.endsWith('/') && requestUrl !== '/' ? requestUrl.slice(0, -1) : requestUrl;
+
+    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(`${this.urlPath}/`)) {
+          return false;
+        }
+
+        return true;
+      }
+
+      return false;
+    }
+  }
+
+  matchEntry(entryName) {
+    return this.spec.entryName === entryName;
+  } // compiler urlPath to regexp if necessary
+
+
+  setupUrlPath() {
+    const {
+      urlPath
+    } = this.spec;
+    this.urlPath = urlPath === '/' ? urlPath : (0, _utils.removeTailSlash)(urlPath);
+    const useReg = regCharsDetector.test(urlPath);
+
+    if (useReg) {
+      this.urlMatcher = (0, _pathToRegexp.match)(urlPath, {
+        end: false,
+        decode: decodeURIComponent
+      });
+      this.urlReg = (0, _pathToRegexp.pathToRegexp)(urlPath, [], {
+        end: false
+      });
+    }
+  }
+
+}
+
+exports.RouteMatcher = RouteMatcher;

package/dist/js/node/libs/route/route.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ModernRoute = void 0;
+
+class ModernRoute {
+  constructor(routeSpec) {
+    var _routeSpec$enableMode;
+
+    this.entryName = void 0;
+    this.urlPath = void 0;
+    this.entryPath = void 0;
+    this.bundle = void 0;
+    this.isApi = void 0;
+    this.isSSR = void 0;
+    this.isSPA = void 0;
+    this.enableModernMode = void 0;
+    this.params = {};
+    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;
+  }
+
+}
+
+exports.ModernRoute = ModernRoute;

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

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createStaticFileHandler = void 0;
+
+var _serveStatic = _interopRequireDefault(require("serve-static"));
+
+var _utils = require("@modern-js/utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Todo 看看是不是能 fork 一份，即使命中也返回
+const createStaticFileHandler = rules => // eslint-disable-next-line consistent-return
+async (context, next) => {
+  const {
+    url: requestUrl,
+    req,
+    res
+  } = context;
+  const hitRule = rules.find(item => {
+    if ((0, _utils.isString)(item.path) && requestUrl.startsWith(item.path)) {
+      return true;
+    } else if ((0, _utils.isRegExp)(item.path) && item.path.test(requestUrl)) {
+      return true;
+    }
+
+    return false;
+  });
+
+  if (hitRule) {
+    (0, _serveStatic.default)(hitRule.target)(req, res, () => {
+      next();
+    });
+  } else {
+    return next();
+  }
+};
+
+exports.createStaticFileHandler = createStaticFileHandler;

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

@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Server = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _serverCore = require("@modern-js/server-core");
+
+var _utils = require("@modern-js/utils");
+
+var _core = require("@modern-js/core");
+
+var _metrics = require("../libs/metrics");
+
+var _modernServer = require("./modern-server");
+
+var _modernServerSplit = require("./modern-server-split");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const createProdServer = options => {
+  if (options.apiOnly) {
+    return new _modernServerSplit.ModernAPIServer(options);
+  } else if (options.ssrOnly) {
+    return new _modernServerSplit.ModernSSRServer(options);
+  } else if (options.webOnly) {
+    return new _modernServerSplit.ModernWebServer(options);
+  } else {
+    return new _modernServer.ModernServer(options);
+  }
+};
+
+class Server {
+  constructor(options) {
+    this.options = void 0;
+    this.serverImpl = createProdServer;
+    this.server = void 0;
+    this.app = void 0;
+    this.runner = void 0;
+    this.options = options;
+  }
+
+  getRequestHandler() {
+    return (req, res, next) => {
+      const requestHandler = this.server.getRequestHandler();
+      return requestHandler(req, res, next);
+    };
+  }
+
+  ready(readyOptions = {}) {
+    this.server.ready(readyOptions);
+  }
+
+  async init() {
+    const {
+      options
+    } = this;
+    options.logger = options.logger || _utils.logger;
+    options.metrics = options.metrics || _metrics.metrics; // initialize server
+
+    this.server = this.serverImpl(options); // create http-server
+
+    this.app = await this.server.createHTTPServer(this.getRequestHandler());
+    this.runner = await this.createHookRunner(); // runner can only be used after server init
+
+    await this.server.init(this.runner);
+    return this;
+  }
+
+  listen(port = 8080, listener) {
+    this.app.listen(process.env.PORT || port, () => {
+      if (listener) {
+        listener();
+      }
+
+      this.listener(this.app);
+    });
+  }
+
+  listener(app) {
+    this.server.onListening(app);
+  }
+
+  async close() {
+    await this.server.close();
+    await new Promise(resolve => this.app.close(() => {
+      resolve();
+    }));
+  }
+
+  async createHookRunner() {
+    var _options$plugins;
+
+    const {
+      options
+    } = this;
+
+    _serverCore.serverManager.clear();
+
+    (_options$plugins = options.plugins) === null || _options$plugins === void 0 ? void 0 : _options$plugins.forEach(p => {
+      _serverCore.serverManager.usePlugin((0, _utils.compatRequire)(p.pluginPath));
+    });
+    const appContext = await this.initAppContext();
+
+    _serverCore.serverManager.run(() => {
+      var _options$config$outpu;
+
+      _serverCore.ConfigContext.set(this.options.config);
+
+      _serverCore.AppContext.set(_objectSpread(_objectSpread({}, appContext), {}, {
+        distDirectory: _path.default.join(options.pwd, ((_options$config$outpu = options.config.output) === null || _options$config$outpu === void 0 ? void 0 : _options$config$outpu.path) || 'dist')
+      }));
+    });
+
+    return _serverCore.serverManager.init({});
+  }
+
+  async initAppContext() {
+    var _this$options$plugins;
+
+    const appDirectory = await (0, _core.initAppDir)();
+    const loaded = await (0, _core.loadUserConfig)(appDirectory);
+    const plugins = (_this$options$plugins = this.options.plugins) === null || _this$options$plugins === void 0 ? void 0 : _this$options$plugins.map(p => ({
+      server: p,
+      cli: undefined
+    }));
+    const appContext = (0, _core.initAppContext)(appDirectory, plugins || [], loaded.filePath);
+    return appContext;
+  }
+
+}
+
+exports.Server = Server;

package/dist/js/node/server/modern-server-split.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ModernWebServer = exports.ModernSSRServer = exports.ModernAPIServer = void 0;
+
+var _modernServer = require("./modern-server");
+
+class ModernSSRServer extends _modernServer.ModernServer {
+  // Todo should not invoke any route hook in modernSSRServer
+  async warmupSSRBundle() {// empty
+  }
+
+  verifyMatch(context, matched) {
+    if (matched.generate(context.url).isApi) {
+      this.render404(context);
+    }
+  }
+
+  prepareAPIHandler(_m, _) {
+    return null;
+  }
+
+  async prepareWebHandler(extension) {
+    return super.prepareWebHandler(extension);
+  } // protected filterRoutes(routes: ModernRouteInterface[]) {
+  //   return routes.filter(route => route.entryName);
+  // }
+
+
+  async preServerInit() {// empty
+  }
+
+}
+
+exports.ModernSSRServer = ModernSSRServer;
+
+class ModernAPIServer extends _modernServer.ModernServer {
+  async emitRouteHook(_, _input) {// empty
+  }
+
+  async warmupSSRBundle() {// empty
+  }
+
+  prepareWebHandler(_) {
+    return null;
+  }
+
+  async prepareAPIHandler(mode, extension) {
+    return super.prepareAPIHandler(mode, extension);
+  }
+
+  filterRoutes(routes) {
+    return routes.filter(route => route.isApi);
+  }
+
+  async preServerInit() {// empty
+  }
+
+}
+
+exports.ModernAPIServer = ModernAPIServer;
+
+class ModernWebServer extends _modernServer.ModernServer {
+  async warmupSSRBundle() {// empty
+  }
+
+  async handleAPI(context) {
+    const {
+      proxyTarget
+    } = this;
+
+    if (!(proxyTarget !== null && proxyTarget !== void 0 && proxyTarget.api)) {
+      this.proxy();
+    } else {
+      this.render404(context);
+    }
+  }
+
+  async handleWeb(context, route) {
+    const {
+      proxyTarget
+    } = this;
+
+    if (route.isSSR && proxyTarget !== null && proxyTarget !== void 0 && proxyTarget.ssr) {
+      return this.proxy();
+    } else {
+      // if no proxyTarget but access web server, degradation to csr
+      route.isSSR = false;
+      return super.handleWeb(context, route);
+    }
+  }
+
+}
+
+exports.ModernWebServer = ModernWebServer;