@modern-js/prod-server 1.0.1

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

@@ -0,0 +1,68 @@
+import { RouteMatcher } from "./matcher";
+export 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 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;
+  }
+
+}
+export { RouteMatcher };

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

@@ -0,0 +1,94 @@
+import { removeTailSlash } from '@modern-js/utils';
+import { match, pathToRegexp } from 'path-to-regexp';
+import { toPath } from "../../utils";
+import { ModernRoute } from "./route"; // eslint-disable-next-line no-useless-escape
+
+const regCharsDetector = /[^a-zA-Z\-_0-9\/\.]/;
+export 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 ModernRoute(this.spec);
+
+    if (this.urlPath) {
+      const params = this.parseURLParams(url);
+      route.urlPath = 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 : removeTailSlash(urlPath);
+    const useReg = regCharsDetector.test(urlPath);
+
+    if (useReg) {
+      this.urlMatcher = match(urlPath, {
+        end: false,
+        decode: decodeURIComponent
+      });
+      this.urlReg = pathToRegexp(urlPath, [], {
+        end: false
+      });
+    }
+  }
+
+}

package/dist/js/modern/libs/route/route.js

@@ -0,0 +1,24 @@
+export 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;
+  }
+
+}

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

@@ -0,0 +1,28 @@
+// Todo 看看是不是能 fork 一份，即使命中也返回
+import serve from 'serve-static';
+import { isString, isRegExp } from '@modern-js/utils';
+export const createStaticFileHandler = rules => // eslint-disable-next-line consistent-return
+async (context, next) => {
+  const {
+    url: requestUrl,
+    req,
+    res
+  } = context;
+  const hitRule = rules.find(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) {
+    serve(hitRule.target)(req, res, () => {
+      next();
+    });
+  } else {
+    return next();
+  }
+};

package/dist/js/modern/server/index.js

@@ -0,0 +1,120 @@
+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; }
+
+import path from 'path';
+import { serverManager, AppContext, ConfigContext } from '@modern-js/server-core';
+import { compatRequire, logger as defaultLogger } from '@modern-js/utils';
+import { initAppContext, initAppDir, loadUserConfig } from '@modern-js/core';
+import { metrics as defaultMetrics } from "../libs/metrics";
+import { ModernServer } from "./modern-server";
+import { ModernAPIServer, ModernSSRServer, ModernWebServer } from "./modern-server-split";
+
+const createProdServer = options => {
+  if (options.apiOnly) {
+    return new ModernAPIServer(options);
+  } else if (options.ssrOnly) {
+    return new ModernSSRServer(options);
+  } else if (options.webOnly) {
+    return new ModernWebServer(options);
+  } else {
+    return new ModernServer(options);
+  }
+};
+
+export 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 || defaultLogger;
+    options.metrics = options.metrics || defaultMetrics; // 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;
+    serverManager.clear();
+    (_options$plugins = options.plugins) === null || _options$plugins === void 0 ? void 0 : _options$plugins.forEach(p => {
+      serverManager.usePlugin(compatRequire(p.pluginPath));
+    });
+    const appContext = await this.initAppContext();
+    serverManager.run(() => {
+      var _options$config$outpu;
+
+      ConfigContext.set(this.options.config);
+      AppContext.set(_objectSpread(_objectSpread({}, appContext), {}, {
+        distDirectory: path.join(options.pwd, ((_options$config$outpu = options.config.output) === null || _options$config$outpu === void 0 ? void 0 : _options$config$outpu.path) || 'dist')
+      }));
+    });
+    return serverManager.init({});
+  }
+
+  async initAppContext() {
+    var _this$options$plugins;
+
+    const appDirectory = await initAppDir();
+    const loaded = await 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 = initAppContext(appDirectory, plugins || [], loaded.filePath);
+    return appContext;
+  }
+
+}

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

@@ -0,0 +1,81 @@
+import { ModernServer } from "./modern-server";
+export class ModernSSRServer extends 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
+  }
+
+}
+export class ModernAPIServer extends 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
+  }
+
+}
+export class ModernWebServer extends 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);
+    }
+  }
+
+}