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

package/dist/esm-node/libs/render/cache/spr.js

@@ -0,0 +1,220 @@
+import crypto from "crypto";
+import LRUCache from "lru-cache";
+import { mime } from "@modern-js/utils";
+import {
+  cacheAddition,
+  connectFactor,
+  fname,
+  maybeSync,
+  namespaceHash,
+  valueFactory,
+  withCoalescedInvoke
+} from "./util";
+import { createPageCaches } from "./page-caches";
+const MAX_CACHE_EACH_REQ = Number(process.env.ROUTE_CACHE_LIMIT) || 10;
+const MAX_SIZE_EACH_CLUSTER = Number(process.env.CLUSTER_CACHE_LIMIT) || 100;
+const BASE_LEVEL = 0;
+const QUERY_LEVEL = 1;
+const HEADER_LEVEL = 2;
+const QUERY_HEADER_LEVEL = 3;
+class CacheManager {
+  constructor(cacheOptions) {
+    this.find = (() => {
+      {
+        const _this = this;
+        return {
+          [fname(BASE_LEVEL)](context, cacheKey) {
+            return _this.md5(cacheKey);
+          },
+          [fname(QUERY_LEVEL)](context, cacheKey, data) {
+            const queryFactor = _this.queryFactor(context, data);
+            if (!queryFactor) {
+              return null;
+            }
+            return _this.md5(connectFactor(cacheKey, queryFactor));
+          },
+          [fname(HEADER_LEVEL)](context, cacheKey, data) {
+            const headerFactor = _this.headerFactor(context, data);
+            if (!headerFactor) {
+              return null;
+            }
+            return _this.md5(connectFactor(cacheKey, headerFactor));
+          },
+          [fname(QUERY_HEADER_LEVEL)](context, cacheKey, data) {
+            const queryFactor = _this.queryFactor(context, data);
+            const headerFactor = _this.headerFactor(context, data);
+            if (!queryFactor || !headerFactor) {
+              return null;
+            }
+            return _this.md5(connectFactor(cacheKey, headerFactor, queryFactor));
+          }
+        };
+      }
+    })();
+    this.cacheOptions = cacheOptions;
+    this.cache = new LRUCache({
+      max: Math.min(MAX_SIZE_EACH_CLUSTER, 600) * 1024 * 1024,
+      length(n) {
+        const len = n.caches.keys().reduce((total, cur) => {
+          var _a;
+          return total + (((_a = n.caches.peek(cur)) == null ? void 0 : _a.size) || 0);
+        }, 1);
+        return len;
+      }
+    });
+  }
+  md5(content) {
+    const md5 = crypto.createHash("md5");
+    return md5.update(content).digest("hex");
+  }
+  generateRequestKey(context) {
+    const { pathname, entry } = context;
+    return this.md5(`${pathname}_${entry}`);
+  }
+  replaceValue(value, matcher) {
+    let final = value;
+    Object.keys(matcher).some((replacer) => {
+      const reg = new RegExp(matcher[replacer]);
+      if (reg.test(value)) {
+        final = replacer;
+        return true;
+      }
+      return false;
+    });
+    return final;
+  }
+  factor(keys, obj, matches = {}) {
+    keys.sort();
+    const getValue = valueFactory(obj);
+    const factorAry = keys.reduce((ary, key) => {
+      let value = getValue(key) || "";
+      const matcher = matches[key];
+      if (matcher) {
+        value = this.replaceValue(value, matcher);
+      }
+      return ary.concat([key, value]);
+    }, []);
+    return factorAry.join(",");
+  }
+  queryFactor(context, data) {
+    var _a, _b;
+    const queryKeys = (_a = data.includes) == null ? void 0 : _a.query;
+    const queryMatches = (_b = data.matches) == null ? void 0 : _b.query;
+    if (!queryKeys || queryKeys.length === 0) {
+      return null;
+    }
+    const requestQuery = context.query;
+    const queryFactor = this.factor(queryKeys, requestQuery, queryMatches);
+    return queryFactor;
+  }
+  headerFactor(context, data) {
+    var _a, _b;
+    const headerKeys = (_a = data.includes) == null ? void 0 : _a.header;
+    const headerMatches = (_b = data.matches) == null ? void 0 : _b.header;
+    if (!headerKeys || headerKeys.length === 0) {
+      return null;
+    }
+    const requestHeader = context.headers;
+    const headerFactor = this.factor(headerKeys, requestHeader, headerMatches);
+    return headerFactor;
+  }
+  async best(context, cacheKey, data) {
+    const { level } = data;
+    const cacheHash = this.find[fname(level)](context, cacheKey, data);
+    if (!cacheHash) {
+      return null;
+    }
+    return data.caches.get(cacheHash);
+  }
+  createCacheContent(config, caches) {
+    return {
+      level: config.level,
+      interval: config.interval,
+      includes: config.includes || null,
+      limit: config.staleLimit,
+      matches: config.matches || null,
+      caches
+    };
+  }
+  async get(context) {
+    const cacheKey = this.generateRequestKey(context);
+    const data = this.cache.get(cacheKey);
+    if (!data) {
+      return null;
+    }
+    const dest = await this.best(context, cacheKey, data);
+    if (!dest) {
+      return null;
+    }
+    const { expireTime, limitTime, html, cacheHash } = dest;
+    const isStale = Date.now() - expireTime > 0;
+    const isGarbage = limitTime ? Date.now() - limitTime > 0 : false;
+    return {
+      content: html || "",
+      contentType: mime.contentType("html"),
+      isStale,
+      isGarbage,
+      hash: cacheHash
+    };
+  }
+  async set(context, html, cacheConfig, sync = false) {
+    if (!cacheConfig) {
+      return false;
+    }
+    const cacheKey = this.generateRequestKey(context);
+    let data = this.cache.get(cacheKey);
+    if (!data) {
+      const caches = await createPageCaches(MAX_CACHE_EACH_REQ);
+      data = this.createCacheContent(cacheConfig, caches);
+    }
+    const cacheHash = this.find[fname(cacheConfig.level)](
+      context,
+      cacheKey,
+      data
+    );
+    if (!cacheHash) {
+      return false;
+    }
+    const cacheSyncOrAsync = async () => {
+      const next = data;
+      const limit = cacheConfig.staleLimit;
+      const storeHTML = cacheAddition(html, cacheHash);
+      const size = storeHTML.length;
+      await next.caches.set(cacheHash, {
+        expireTime: Date.now() + cacheConfig.interval * 1e3,
+        limitTime: typeof limit === "number" ? Date.now() + limit * 1e3 : null,
+        cacheHash,
+        html: storeHTML,
+        size
+      });
+      this.cache.set(cacheKey, next);
+      return true;
+    };
+    const doCache = withCoalescedInvoke(cacheSyncOrAsync).bind(
+      null,
+      namespaceHash("stream", cacheHash),
+      []
+    );
+    return maybeSync(doCache)(sync);
+  }
+  async del(context, cacheHash) {
+    const cacheKey = this.generateRequestKey(context);
+    const data = this.cache.get(cacheKey);
+    data == null ? void 0 : data.caches.del(cacheHash);
+  }
+}
+let manager;
+function createCache() {
+  if (manager) {
+    return manager;
+  }
+  manager = new CacheManager({ max: 0 });
+  return manager;
+}
+function destroyCache() {
+  manager = null;
+}
+export {
+  createCache,
+  destroyCache
+};

package/dist/esm-node/libs/render/cache/util.js

@@ -0,0 +1,80 @@
+import url from "url";
+function namespaceHash(namespace, hash) {
+  return `${namespace}/${hash}`;
+}
+function fname(lv) {
+  return `f${lv}`;
+}
+function connectFactor(...args) {
+  return args.join("-");
+}
+function valueFactory(obj) {
+  if (obj instanceof url.URLSearchParams) {
+    return function(key) {
+      return obj.get(key);
+    };
+  } else {
+    return function(key) {
+      const value = obj[key];
+      if (Array.isArray(value)) {
+        return value.join(",");
+      }
+      return value;
+    };
+  }
+}
+function getTime([s, ns]) {
+  return Math.floor(s * 1e3 + ns / 1e6);
+}
+const RE_START_IN_HEAD = /<head>/;
+function cacheAddition(html, hash) {
+  const additionHtml = html.replace(
+    RE_START_IN_HEAD,
+    `<head><meta name="x-moden-spr" content="${hash}">`
+  );
+  return additionHtml;
+}
+const globalInvokeCache = /* @__PURE__ */ new Map();
+function withCoalescedInvoke(func) {
+  return async function(key, args) {
+    const entry = globalInvokeCache.get(key);
+    if (entry) {
+      return entry.then((res) => ({
+        isOrigin: false,
+        value: res.value
+      }));
+    }
+    function __wrapper() {
+      return func(...args);
+    }
+    const future = __wrapper().then((res) => {
+      globalInvokeCache.delete(key);
+      return { isOrigin: true, value: res };
+    }).catch((err) => {
+      globalInvokeCache.delete(key);
+      throw err;
+    });
+    globalInvokeCache.set(key, future);
+    return future;
+  };
+}
+function maybeSync(fn) {
+  return (sync) => {
+    if (sync) {
+      return fn();
+    } else {
+      fn();
+      return Promise.resolve();
+    }
+  };
+}
+export {
+  cacheAddition,
+  connectFactor,
+  fname,
+  getTime,
+  maybeSync,
+  namespaceHash,
+  valueFactory,
+  withCoalescedInvoke
+};

package/dist/esm-node/libs/render/index.js

@@ -0,0 +1,64 @@
+import path from "path";
+import { fs, mime } from "@modern-js/utils";
+import { ERROR_DIGEST } from "../../constants";
+import { handleDirectory } from "./static";
+import { readFile } from "./reader";
+import * as ssr from "./ssr";
+const createRenderHandler = ({
+  distDir,
+  staticGenerate,
+  forceCSR
+}) => async function render({
+  ctx,
+  route,
+  runner
+}) {
+  if (ctx.resHasHandled()) {
+    return null;
+  }
+  const { entryPath, urlPath } = route;
+  const entry = path.join(distDir, entryPath);
+  if (!route.isSPA) {
+    const result = await handleDirectory(ctx, entry, urlPath);
+    return result;
+  }
+  const templatePath = entry;
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`Could not find template file: ${templatePath}`);
+  }
+  const content = await readFile(templatePath);
+  if (!content) {
+    return null;
+  }
+  const useCSR = forceCSR && ctx.query.csr;
+  if (route.isSSR && !useCSR) {
+    try {
+      const result = await ssr.render(
+        ctx,
+        {
+          distDir,
+          entryName: route.entryName,
+          urlPath: route.urlPath,
+          bundle: route.bundle,
+          template: content.toString(),
+          staticGenerate
+        },
+        runner
+      );
+      return result;
+    } catch (err) {
+      ctx.error(
+        ERROR_DIGEST.ERENDER,
+        err.stack || err.message
+      );
+      ctx.res.setHeader("x-modern-ssr-fallback", "1");
+    }
+  }
+  return {
+    content,
+    contentType: mime.contentType(path.extname(templatePath))
+  };
+};
+export {
+  createRenderHandler
+};

package/dist/esm-node/libs/render/measure.js

@@ -0,0 +1,51 @@
+import { headersWithoutCookie } from "../../utils";
+const createMetrics = (context, metrics) => {
+  const { entryName: entry, request } = context;
+  const { pathname = "" } = request || {};
+  const emitTimer = (name, cost, tags = {}) => {
+    metrics.emitTimer(name, cost, {
+      ...tags,
+      pathname,
+      entry
+    });
+  };
+  const emitCounter = (name, counter, tags = {}) => {
+    metrics.emitCounter(name, counter, {
+      ...tags,
+      pathname,
+      entry
+    });
+  };
+  return { emitTimer, emitCounter };
+};
+const createLogger = (serverContext, logger) => {
+  const request = serverContext.request || {};
+  const { headers = {}, pathname = "" } = request;
+  const debug = (message, ...args) => {
+    logger.debug(`SSR Debug - ${message}, req.url = %s`, ...args, pathname);
+  };
+  const info = (message, ...args) => {
+    logger.info(`SSR Info - ${message}, req.url = %s`, ...args, pathname);
+  };
+  const error = (message, e) => {
+    if (!e) {
+      e = message;
+      message = "";
+    }
+    logger.error(
+      `SSR Error - ${message}, error = %s, req.url = %s, req.headers = %o`,
+      e instanceof Error ? e.stack || e.message : e,
+      pathname,
+      headersWithoutCookie(headers)
+    );
+  };
+  return {
+    error,
+    info,
+    debug
+  };
+};
+export {
+  createLogger,
+  createMetrics
+};

package/dist/esm-node/libs/render/reader.js

@@ -0,0 +1,85 @@
+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 = async (filepath, mtime) => {
+  const content = await fs.readFile(filepath);
+  return {
+    content,
+    mtime
+  };
+};
+class LruReader {
+  constructor() {
+    this.cache = new LRU({
+      max: 256 * MB,
+      length: getContentLength,
+      maxAge: 5 * 60 * 5e3
+    });
+  }
+  init() {
+  }
+  close() {
+  }
+  async read(filepath) {
+    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 = await 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 = async (filepath) => {
+  const file = await 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/esm-node/libs/render/ssr.js

@@ -0,0 +1,80 @@
+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 = async (ctx, renderOptions, runner) => {
+  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 = await 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/esm-node/libs/render/static.js

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