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

package/dist/cjs/libs/render/cache/__tests__/error-configuration.js

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_configuration_exports = {};
+__export(error_configuration_exports, {
+  errorConfiguration: () => errorConfiguration
+});
+module.exports = __toCommonJS(error_configuration_exports);
+const errorConfiguration = [
+  { level: 1 },
+  {
+    level: 1,
+    includes: {}
+  },
+  {
+    level: 1,
+    includes: { query: [] }
+  },
+  {
+    level: 2,
+    includes: {}
+  },
+  {
+    level: 2,
+    includes: { header: [] }
+  },
+  {
+    level: 3,
+    includes: { header: [] }
+  },
+  {
+    level: 3,
+    includes: { query: [] }
+  },
+  {
+    level: 3,
+    includes: {
+      query: [],
+      header: []
+    }
+  }
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  errorConfiguration
+});

package/dist/cjs/libs/render/cache/__tests__/matched-cache.js

@@ -0,0 +1,114 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var matched_cache_exports = {};
+__export(matched_cache_exports, {
+  matchedCacheableAry: () => matchedCacheableAry
+});
+module.exports = __toCommonJS(matched_cache_exports);
+const matchedCacheableAry = [
+  [
+    {
+      requestOpt: {
+        url: "/level-one",
+        headers: {},
+        query: { name: "byted" }
+      },
+      cacheConfig: {
+        level: 1,
+        includes: { query: ["name"] },
+        matches: { query: { name: { weixin: "^byted" } } }
+      },
+      content: "level1"
+    },
+    {
+      url: "/level-one",
+      headers: {},
+      query: { name: "byted_likely" }
+    },
+    {
+      url: "/level-one",
+      headers: {},
+      query: { name: "not_byted" }
+    }
+  ],
+  [
+    {
+      requestOpt: {
+        url: "/level-two",
+        query: {},
+        headers: { age: "17" }
+      },
+      cacheConfig: {
+        level: 2,
+        includes: { header: ["age"] },
+        matches: { header: { age: { one: "^1" } } }
+      },
+      content: "level2"
+    },
+    {
+      url: "/level-two",
+      query: {},
+      headers: { age: "11" }
+    },
+    {
+      url: "/level-two",
+      query: {},
+      headers: { age: "22" }
+    }
+  ],
+  [
+    {
+      requestOpt: {
+        url: "/level-three",
+        headers: { age: "17" },
+        query: { name: "byted" }
+      },
+      cacheConfig: {
+        level: 3,
+        includes: {
+          query: ["name"],
+          header: ["age"]
+        },
+        matches: {
+          query: { name: { weixin: "^byted" } },
+          header: { age: { one: "^1" } }
+        }
+      },
+      content: "level3"
+    },
+    {
+      url: "/level-three",
+      query: { name: "byted_likely" },
+      headers: { age: "19" }
+    },
+    {
+      url: "/level-three",
+      query: { name: "byted_likely" },
+      headers: {}
+    },
+    {
+      url: "/level-three",
+      query: { name: "not_byted" },
+      headers: { age: "19" }
+    }
+  ]
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  matchedCacheableAry
+});

package/dist/cjs/libs/render/cache/index.js

@@ -0,0 +1,97 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cache_exports = {};
+__export(cache_exports, {
+  default: () => cache_default
+});
+module.exports = __toCommonJS(cache_exports);
+var import_stream = require("stream");
+var import_constants = require("../../../constants");
+var import_spr = require("./spr");
+var import_util = require("./util");
+var cache_default = (renderFn, ctx) => {
+  const sprCache = (0, import_spr.createCache)();
+  const doRender = async (context) => {
+    const cacheContext = {
+      entry: context.entryName,
+      ...context.request
+    };
+    const cacheFile = await sprCache.get(cacheContext);
+    async function afterRender(source, onAfterRender) {
+      if (!source) {
+        return "";
+      }
+      if (typeof source === "string") {
+        await onAfterRender(source);
+        return source;
+      } else {
+        let htmlForStream = "";
+        const cacheStream = new import_stream.Transform({
+          write(chunk, _, callback) {
+            htmlForStream += chunk.toString();
+            this.push(chunk);
+            callback();
+          }
+        });
+        cacheStream.on("close", () => onAfterRender(htmlForStream));
+        return source(cacheStream);
+      }
+    }
+    async function saveHtmlIntoCache(html) {
+      const { cacheConfig } = context;
+      if (html && cacheConfig) {
+        await sprCache.set(cacheContext, html, cacheConfig);
+      }
+    }
+    if (!cacheFile) {
+      const renderResult = await renderFn(context);
+      return afterRender(renderResult, saveHtmlIntoCache);
+    }
+    const cacheHash = cacheFile == null ? void 0 : cacheFile.hash;
+    if (cacheFile.isGarbage) {
+      const renderResult = await renderFn(context);
+      return afterRender(renderResult, saveHtmlIntoCache);
+    } else if (cacheFile.isStale) {
+      const render = (0, import_util.withCoalescedInvoke)(() => renderFn(context)).bind(
+        null,
+        (0, import_util.namespaceHash)("render", cacheFile.hash),
+        []
+      );
+      render().then(async (res) => {
+        if (res.value && res.isOrigin) {
+          const { cacheConfig } = context;
+          if (cacheConfig) {
+            afterRender(res.value, async (html) => {
+              sprCache.set(cacheContext, html, cacheConfig);
+            });
+          } else {
+            sprCache.del(cacheContext, cacheHash);
+          }
+        }
+      }).catch((e) => {
+        sprCache.del(cacheContext, cacheHash);
+        ctx.error(import_constants.ERROR_DIGEST.ERENDER, e);
+      });
+    }
+    ctx.res.setHeader("x-modern-spr", "1");
+    return cacheFile.content;
+  };
+  return doRender;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/cjs/libs/render/cache/page-caches/index.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var page_caches_exports = {};
+__export(page_caches_exports, {
+  createPageCaches: () => createPageCaches
+});
+module.exports = __toCommonJS(page_caches_exports);
+var import_lru = require("./lru");
+async function createPageCaches(max) {
+  const constructorOptions = { max };
+  const cacheInstance = new import_lru.LRUCaches(constructorOptions);
+  await cacheInstance.init();
+  return cacheInstance;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPageCaches
+});

package/dist/cjs/libs/render/cache/page-caches/lru.js

@@ -0,0 +1,58 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lru_exports = {};
+__export(lru_exports, {
+  LRUCaches: () => LRUCaches
+});
+module.exports = __toCommonJS(lru_exports);
+var import_lru_cache = __toESM(require("lru-cache"));
+class LRUCaches {
+  constructor(options) {
+    this.max = options.max;
+    this.caches = new import_lru_cache.default(this.max);
+  }
+  init() {
+    return Promise.resolve();
+  }
+  keys() {
+    return this.caches.keys();
+  }
+  get(key) {
+    return Promise.resolve(this.caches.get(key) || null);
+  }
+  peek(key) {
+    return this.caches.peek(key) || null;
+  }
+  set(key, cache) {
+    this.caches.set(key, cache);
+    return Promise.resolve();
+  }
+  del(key) {
+    this.caches.del(key);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LRUCaches
+});

package/dist/cjs/libs/render/cache/spr.js

@@ -0,0 +1,242 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var spr_exports = {};
+__export(spr_exports, {
+  createCache: () => createCache,
+  destroyCache: () => destroyCache
+});
+module.exports = __toCommonJS(spr_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_lru_cache = __toESM(require("lru-cache"));
+var import_utils = require("@modern-js/utils");
+var import_util = require("./util");
+var import_page_caches = require("./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 {
+          [(0, import_util.fname)(BASE_LEVEL)](context, cacheKey) {
+            return _this.md5(cacheKey);
+          },
+          [(0, import_util.fname)(QUERY_LEVEL)](context, cacheKey, data) {
+            const queryFactor = _this.queryFactor(context, data);
+            if (!queryFactor) {
+              return null;
+            }
+            return _this.md5((0, import_util.connectFactor)(cacheKey, queryFactor));
+          },
+          [(0, import_util.fname)(HEADER_LEVEL)](context, cacheKey, data) {
+            const headerFactor = _this.headerFactor(context, data);
+            if (!headerFactor) {
+              return null;
+            }
+            return _this.md5((0, import_util.connectFactor)(cacheKey, headerFactor));
+          },
+          [(0, import_util.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((0, import_util.connectFactor)(cacheKey, headerFactor, queryFactor));
+          }
+        };
+      }
+    })();
+    this.cacheOptions = cacheOptions;
+    this.cache = new import_lru_cache.default({
+      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 = import_crypto.default.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 = (0, import_util.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[(0, import_util.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: import_utils.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 (0, import_page_caches.createPageCaches)(MAX_CACHE_EACH_REQ);
+      data = this.createCacheContent(cacheConfig, caches);
+    }
+    const cacheHash = this.find[(0, import_util.fname)(cacheConfig.level)](
+      context,
+      cacheKey,
+      data
+    );
+    if (!cacheHash) {
+      return false;
+    }
+    const cacheSyncOrAsync = async () => {
+      const next = data;
+      const limit = cacheConfig.staleLimit;
+      const storeHTML = (0, import_util.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 = (0, import_util.withCoalescedInvoke)(cacheSyncOrAsync).bind(
+      null,
+      (0, import_util.namespaceHash)("stream", cacheHash),
+      []
+    );
+    return (0, import_util.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCache,
+  destroyCache
+});

package/dist/cjs/libs/render/cache/type.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var type_exports = {};
+module.exports = __toCommonJS(type_exports);