@modern-js/prod-server 2.5.0 → 2.5.1-alpha.0

package/dist/js/modern/libs/render/reader.js

@@ -0,0 +1,107 @@
+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 { fs } from "@modern-js/utils";
+import LRU from "lru-cache";
+const Byte = 1;
+const KB = 1024 * Byte;
+const MB = 1024 * KB;
+const getContentLength = (cache) => cache.content.length;
+const createCacheItem = (filepath, mtime) => __async(void 0, null, function* () {
+  const content = yield fs.readFile(filepath);
+  return {
+    content,
+    mtime
+  };
+});
+class LruReader {
+  constructor() {
+    this.cache = new LRU({
+      max: 256 * MB,
+      length: getContentLength,
+      maxAge: 5 * 60 * 5e3
+    });
+  }
+  init() {
+  }
+  close() {
+  }
+  read(filepath) {
+    return __async(this, null, function* () {
+      if (this.cache.has(filepath)) {
+        const { content } = this.cache.get(filepath);
+        return { content };
+      }
+      if (!fs.existsSync(filepath)) {
+        return null;
+      }
+      const stat = fs.statSync(filepath);
+      if (stat.isDirectory()) {
+        return null;
+      }
+      if (stat.size > 20 * MB) {
+        return null;
+      }
+      const item = yield createCacheItem(filepath, stat.mtime);
+      this.cache.set(filepath, item);
+      return item;
+    });
+  }
+  update() {
+    const { cache } = this;
+    const files = cache.keys();
+    for (const filepath of files) {
+      if (!fs.existsSync(filepath)) {
+        cache.del(filepath);
+      }
+      try {
+        const item = cache.get(filepath);
+        const stat = fs.statSync(filepath);
+        const { mtime } = stat;
+        if (item.mtime < mtime) {
+          cache.del(filepath);
+        }
+      } catch (e) {
+        cache.del(filepath);
+      }
+    }
+  }
+}
+const reader = new LruReader();
+const readFile = (filepath) => __async(void 0, null, function* () {
+  const file = yield reader.read(filepath);
+  return file == null ? void 0 : file.content;
+});
+const updateFile = () => {
+  reader.update();
+};
+const init = () => {
+  reader.init();
+};
+const close = () => {
+  reader.close();
+};
+export {
+  LruReader,
+  close,
+  init,
+  readFile,
+  updateFile
+};

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

@@ -0,0 +1,100 @@
+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,
+  LOADABLE_STATS_FILE,
+  mime,
+  ROUTE_MINIFEST_FILE,
+  SERVER_RENDER_FUNCTION_NAME
+} from "@modern-js/utils";
+import cookie from "cookie";
+import cache from "./cache";
+import { createLogger, createMetrics } from "./measure";
+const render = (ctx, renderOptions, runner) => __async(void 0, null, function* () {
+  var _a;
+  const { urlPath, bundle, distDir, template, entryName, staticGenerate } = renderOptions;
+  const bundleJS = path.join(distDir, bundle);
+  const loadableUri = path.join(distDir, LOADABLE_STATS_FILE);
+  const loadableStats = fs.existsSync(loadableUri) ? require(loadableUri) : "";
+  const routesManifestUri = path.join(distDir, ROUTE_MINIFEST_FILE);
+  const routeManifest = fs.existsSync(routesManifestUri) ? require(routesManifestUri) : void 0;
+  const context = {
+    request: {
+      baseUrl: urlPath,
+      params: ctx.params,
+      pathname: ctx.path,
+      host: ctx.host,
+      query: ctx.query,
+      url: ctx.href,
+      cookieMap: cookie.parse(ctx.headers.cookie || ""),
+      headers: ctx.headers
+    },
+    response: {
+      setHeader: (key, value) => {
+        return ctx.res.setHeader(key, value);
+      },
+      status: (code) => {
+        ctx.res.statusCode = code;
+      },
+      locals: ((_a = ctx.res) == null ? void 0 : _a.locals) || {}
+    },
+    redirection: {},
+    template,
+    loadableStats,
+    routeManifest,
+    entryName,
+    staticGenerate,
+    logger: void 0,
+    metrics: void 0,
+    req: ctx.req,
+    res: ctx.res
+  };
+  context.logger = createLogger(context, ctx.logger);
+  context.metrics = createMetrics(context, ctx.metrics);
+  runner.extendSSRContext(context);
+  const serverRender = require(bundleJS)[SERVER_RENDER_FUNCTION_NAME];
+  const content = yield cache(serverRender, ctx)(context);
+  const { url, status = 302 } = context.redirection;
+  if (url) {
+    return {
+      content: url,
+      contentType: "",
+      statusCode: status,
+      redirect: true
+    };
+  }
+  if (typeof content === "string") {
+    return {
+      content,
+      contentType: mime.contentType("html")
+    };
+  } else {
+    return {
+      content: "",
+      contentStream: content,
+      contentType: mime.contentType("html")
+    };
+  }
+});
+export {
+  render
+};

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

@@ -0,0 +1,60 @@
+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 { mime } from "@modern-js/utils";
+import { readFile } from "./reader";
+function handleDirectory(ctx, entryPath, urlPath) {
+  return __async(this, null, function* () {
+    const { path: pathname } = ctx;
+    const filepath = path.join(entryPath, trimLeft(pathname, urlPath));
+    let content = yield readFile(filepath);
+    let contentType = mime.contentType(path.extname(filepath) || "");
+    if (!content) {
+      if (pathname.endsWith("/")) {
+        content = yield readFile(`${filepath}index.html`);
+      } else if (!pathname.includes(".")) {
+        content = yield readFile(`${filepath}.html`);
+        if (!content) {
+          content = yield readFile(`${filepath}/index.html`);
+        }
+      }
+      if (content) {
+        contentType = mime.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;
+};
+export {
+  handleDirectory
+};

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

@@ -0,0 +1,9 @@
+var RenderLevel = /* @__PURE__ */ ((RenderLevel2) => {
+  RenderLevel2[RenderLevel2["CLIENT_RENDER"] = 0] = "CLIENT_RENDER";
+  RenderLevel2[RenderLevel2["SERVER_PREFETCH"] = 1] = "SERVER_PREFETCH";
+  RenderLevel2[RenderLevel2["SERVER_RENDER"] = 2] = "SERVER_RENDER";
+  return RenderLevel2;
+})(RenderLevel || {});
+export {
+  RenderLevel
+};

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

@@ -0,0 +1,54 @@
+import { RouteMatcher } from "./matcher";
+class RouteMatchManager {
+  constructor() {
+    this.specs = [];
+    this.matchers = [];
+  }
+  filter(pathname) {
+    return this.matchers.reduce((matches, matcher) => {
+      if (matcher.matchUrlPath(pathname)) {
+        matches.push(matcher);
+      }
+      return 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(specs) {
+    this.specs = specs;
+    const matchers = specs.reduce((ms, spec) => {
+      ms.push(new RouteMatcher(spec));
+      return ms;
+    }, []);
+    this.matchers = matchers;
+  }
+  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 {
+  RouteMatchManager,
+  RouteMatcher
+};

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

@@ -0,0 +1,87 @@
+import {
+  match,
+  pathToRegexp,
+  compile
+} from "path-to-regexp";
+import { ModernRoute } from "./route";
+const removeTailSlash = (s) => s.replace(/\/+$/, "");
+const removeHtmlSuffix = (url) => {
+  if (url.endsWith(".html")) {
+    return url.slice(0, -5);
+  }
+  return url;
+};
+const toPath = (reg, params) => {
+  const fn = compile(reg, { encode: encodeURIComponent });
+  return fn(params);
+};
+const regCharsDetector = /[^a-zA-Z\-_0-9\/\.]/;
+class RouteMatcher {
+  constructor(spec) {
+    this.urlPath = "";
+    this.spec = spec;
+    this.setupUrlPath();
+  }
+  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;
+    }
+  }
+  matchLength(pathname) {
+    var _a;
+    if (!this.urlReg) {
+      return this.urlPath.length;
+    } else {
+      const result = this.urlReg.exec(pathname);
+      return ((_a = result == null ? void 0 : result[0]) == null ? void 0 : _a.length) || null;
+    }
+  }
+  matchUrlPath(requestUrl) {
+    let urlWithoutSlash = requestUrl.endsWith("/") && requestUrl !== "/" ? requestUrl.slice(0, -1) : requestUrl;
+    urlWithoutSlash = removeHtmlSuffix(urlWithoutSlash);
+    if (this.urlMatcher) {
+      return Boolean(this.urlMatcher(urlWithoutSlash));
+    } else {
+      const urlPath = removeHtmlSuffix(this.urlPath);
+      if (urlWithoutSlash.startsWith(urlPath)) {
+        if (urlPath !== "/" && urlWithoutSlash.length > urlPath.length && !urlWithoutSlash.startsWith(`${urlPath}/`)) {
+          return false;
+        }
+        return true;
+      }
+      return false;
+    }
+  }
+  matchEntry(entryName) {
+    return this.spec.entryName === entryName;
+  }
+  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
+      });
+    }
+  }
+}
+export {
+  RouteMatcher
+};

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

@@ -0,0 +1,16 @@
+class ModernRoute {
+  constructor(routeSpec) {
+    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.responseHeaders = routeSpec.responseHeaders;
+  }
+}
+export {
+  ModernRoute
+};

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

@@ -0,0 +1,67 @@
+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 serve from "serve-static";
+import { isString, isRegExp } from "@modern-js/utils";
+import { useLocalPrefix } from "../utils";
+const removedPrefix = (req, prefix) => {
+  if (useLocalPrefix(prefix)) {
+    req.url = req.url.slice(prefix.length);
+    return () => {
+      req.url = prefix + req.url;
+    };
+  } else {
+    return () => {
+    };
+  }
+};
+const faviconFallbackHandler = (context, next) => {
+  if (context.url === "/favicon.ico") {
+    context.res.statusCode = 204;
+    context.res.end();
+  } else {
+    next();
+  }
+};
+const createStaticFileHandler = (rules, output = {}) => (context, next) => __async(void 0, null, function* () {
+  const { url: requestUrl, req, res } = context;
+  const { assetPrefix = "/" } = output;
+  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) {
+    const resume = removedPrefix(req, assetPrefix);
+    serve(hitRule.target)(req, res, () => {
+      resume();
+      next();
+    });
+  } else {
+    return next();
+  }
+});
+export {
+  createStaticFileHandler,
+  faviconFallbackHandler
+};

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

@@ -0,0 +1,208 @@
+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 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";
+class Server {
+  constructor(options) {
+    this.serverImpl = createProdServer;
+    options.logger = options.logger || new Logger({
+      level: "warn"
+    });
+    options.metrics = options.metrics || defaultMetrics;
+    this.options = options;
+    this.serverConfig = {};
+  }
+  init() {
+    return __async(this, null, function* () {
+      const { options } = this;
+      this.loadServerEnv(options);
+      this.initServerConfig(options);
+      yield this.injectContext(this.runner, options);
+      this.runner = yield this.createHookRunner();
+      yield this.initConfig(this.runner, options);
+      yield this.injectContext(this.runner, options);
+      this.server = this.serverImpl(options);
+      yield this.runPrepareHook(this.runner);
+      this.app = yield this.server.createHTTPServer(this.getRequestHandler());
+      yield this.server.onInit(this.runner, this.app);
+      return this;
+    });
+  }
+  runConfigHook(runner, serverConfig) {
+    const newServerConfig = runner.config(serverConfig || {});
+    return newServerConfig;
+  }
+  runPrepareHook(runner) {
+    return __async(this, null, function* () {
+      runner.prepare();
+    });
+  }
+  initServerConfig(options) {
+    const { pwd, serverConfigFile } = options;
+    const distDirectory = path.join(pwd, options.config.output.path || "dist");
+    const serverConfigPath = getServerConfigPath(
+      distDirectory,
+      serverConfigFile
+    );
+    const serverConfig = requireConfig(serverConfigPath);
+    this.serverConfig = serverConfig;
+  }
+  initConfig(runner, options) {
+    return __async(this, null, function* () {
+      const { pwd, config } = options;
+      const { serverConfig } = this;
+      const finalServerConfig = this.runConfigHook(runner, serverConfig);
+      const resolvedConfigPath = path.join(
+        pwd,
+        config.output.path || "dist",
+        OUTPUT_CONFIG_FILE
+      );
+      options.config = loadConfig({
+        cliConfig: config,
+        serverConfig: finalServerConfig,
+        resolvedConfigPath
+      });
+    });
+  }
+  close() {
+    return __async(this, null, function* () {
+      this.app.close();
+    });
+  }
+  listen(options, listener) {
+    const callback = () => {
+      listener == null ? void 0 : listener();
+    };
+    if (typeof options === "object") {
+      this.app.listen(options, callback);
+    } else {
+      this.app.listen(process.env.PORT || options || 8080, callback);
+    }
+  }
+  getRequestHandler() {
+    return (req, res, next) => {
+      const requestHandler = this.server.getRequestHandler();
+      return requestHandler(req, res, next);
+    };
+  }
+  render(req, res, url) {
+    return __async(this, null, function* () {
+      return this.server.render(req, res, url);
+    });
+  }
+  createHookRunner() {
+    return __async(this, null, function* () {
+      serverManager.clear();
+      const { options } = this;
+      const {
+        internalPlugins = INTERNAL_SERVER_PLUGINS,
+        pwd,
+        plugins = []
+      } = options;
+      const serverPlugins = this.serverConfig.plugins || [];
+      const loadedPlugins = loadPlugins(pwd, [...serverPlugins, ...plugins], {
+        internalPlugins
+      });
+      debug("plugins", loadedPlugins);
+      loadedPlugins.forEach((p) => {
+        serverManager.usePlugin(p);
+      });
+      const hooksRunner = yield serverManager.init();
+      return hooksRunner;
+    });
+  }
+  injectContext(runner, options) {
+    return __async(this, null, function* () {
+      const appContext = this.initAppContext();
+      const { config, pwd } = options;
+      ConfigContext.set(config);
+      AppContext.set(__spreadProps(__spreadValues({}, appContext), {
+        distDirectory: path.join(pwd, config.output.path || "dist")
+      }));
+    });
+  }
+  initAppContext() {
+    const { options } = this;
+    const { pwd: appDirectory, plugins = [], config } = options;
+    const serverPlugins = plugins.map((p) => ({
+      server: p
+    }));
+    return {
+      appDirectory,
+      distDirectory: path.join(appDirectory, config.output.path || "dist"),
+      sharedDirectory: path.resolve(appDirectory, SHARED_DIR),
+      plugins: serverPlugins
+    };
+  }
+  loadServerEnv(options) {
+    const { pwd: appDirectory } = options;
+    const serverEnv = process.env.MODERN_ENV;
+    const serverEnvPath = path.resolve(appDirectory, `.env.${serverEnv}`);
+    if (serverEnv && fs.existsSync(serverEnvPath) && !fs.statSync(serverEnvPath).isDirectory()) {
+      const envConfig = dotenv.config({ path: serverEnvPath });
+      dotenvExpand(envConfig);
+    }
+  }
+}
+export {
+  Server
+};