@modern-js/prod-server 2.4.0 → 2.5.0

package/dist/{js/node → cjs}/libs/render/cache/__tests__/cache.test.js

@@ -1,55 +1,20 @@
-var __defProp = Object.defineProperty;
-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 __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());
-  });
-};
 var import_spr = require("../spr");
 var import_error_configuration = require("./error-configuration");
 var import_cacheable = require("./cacheable");
 var import_matched_cache = require("./matched-cache");
-const createCacheConfig = (config = {}) => __spreadValues({
+const createCacheConfig = (config = {}) => ({
   excludes: null,
   includes: null,
   interval: 10,
   staleLimit: false,
   level: 0,
   fallback: false,
-  matches: null
-}, config);
+  matches: null,
+  ...config
+});
 jest.setTimeout(6e4);
 describe("cache", () => {
-  it("should cache correctly", () => __async(exports, null, function* () {
+  it("should cache correctly", async () => {
     (0, import_spr.destroyCache)();
     const cache = (0, import_spr.createCache)();
     const context = {
@@ -60,12 +25,12 @@ describe("cache", () => {
     };
     const content = "hello";
     const cacheConfig = createCacheConfig();
-    yield cache.set(context, content, cacheConfig, true);
-    const cacheResult = yield cache.get(context);
+    await cache.set(context, content, cacheConfig, true);
+    const cacheResult = await cache.get(context);
     expect(cacheResult).not.toBe(null);
     expect(cacheResult == null ? void 0 : cacheResult.content).toBe("hello");
-  }));
-  it("should ignore cache set when cache config not exist", () => __async(exports, null, function* () {
+  });
+  it("should ignore cache set when cache config not exist", async () => {
     (0, import_spr.destroyCache)();
     (0, import_spr.destroyCache)();
     const cache = (0, import_spr.createCache)();
@@ -76,10 +41,10 @@ describe("cache", () => {
       headers: {}
     };
     const content = "hello";
-    const shouldCache = yield cache.set(context, content, null, true);
+    const shouldCache = await cache.set(context, content, null, true);
     expect(shouldCache).toBe(false);
-  }));
-  it("should calcual cache key error", () => __async(exports, null, function* () {
+  });
+  it("should calcual cache key error", async () => {
     (0, import_spr.destroyCache)();
     const cache = (0, import_spr.createCache)();
     const content = "hello";
@@ -92,11 +57,11 @@ describe("cache", () => {
         query: {},
         headers: {}
       };
-      const shouldCache = yield cache.set(context, content, cacheConfig);
+      const shouldCache = await cache.set(context, content, cacheConfig);
       expect(shouldCache).toBe(false);
     }
-  }));
-  it("should get nothing for diff requestKey", () => __async(exports, null, function* () {
+  });
+  it("should get nothing for diff requestKey", async () => {
     (0, import_spr.destroyCache)();
     const cache = (0, import_spr.createCache)();
     const context = {
@@ -110,17 +75,17 @@ describe("cache", () => {
       level: 1,
       includes: { query: ["name"] }
     });
-    yield cache.set(context, content, cacheConfig, true);
+    await cache.set(context, content, cacheConfig, true);
     const context_req = {
       entry: "",
       pathname: "/home",
       query: {},
       headers: {}
     };
-    const cacheResult = yield cache.get(context_req);
+    const cacheResult = await cache.get(context_req);
     expect(cacheResult).toBe(null);
-  }));
-  it("should get nothing for diff cacheHash", () => __async(exports, null, function* () {
+  });
+  it("should get nothing for diff cacheHash", async () => {
     (0, import_spr.destroyCache)();
     const cache = (0, import_spr.createCache)();
     const context = {
@@ -134,17 +99,17 @@ describe("cache", () => {
       level: 1,
       includes: { query: ["name"] }
     });
-    yield cache.set(context, content, cacheConfig, true);
+    await cache.set(context, content, cacheConfig, true);
     const context_req = {
       entry: "",
       pathname: "",
       query: { name: "zll" },
       headers: {}
     };
-    const cacheResult = yield cache.get(context_req);
+    const cacheResult = await cache.get(context_req);
     expect(cacheResult).toBe(null);
-  }));
-  it("should get cache correctly", () => __async(exports, null, function* () {
+  });
+  it("should get cache correctly", async () => {
     (0, import_spr.destroyCache)();
     const cache = (0, import_spr.createCache)();
     for (const cacheable of import_cacheable.cacheabelAry) {
@@ -155,12 +120,12 @@ describe("cache", () => {
         headers: cacheable.requestOpt.headers || {}
       };
       const cacheConfig = createCacheConfig(cacheable.cacheConfig || {});
-      yield cache.set(context, cacheable.content, cacheConfig, true);
-      const cacheResult = yield cache.get(context);
+      await cache.set(context, cacheable.content, cacheConfig, true);
+      const cacheResult = await cache.get(context);
       expect(cacheResult == null ? void 0 : cacheResult.content).toBe(cacheable.content);
     }
-  }));
-  it("should match cache correctly", () => __async(exports, null, function* () {
+  });
+  it("should match cache correctly", async () => {
     (0, import_spr.destroyCache)();
     const cache = (0, import_spr.createCache)();
     for (const cacheable of import_matched_cache.matchedCacheableAry) {
@@ -172,14 +137,14 @@ describe("cache", () => {
         query: requestOpt.query,
         headers: requestOpt.headers
       };
-      yield cache.set(context, content, createCacheConfig(cacheConfig), true);
+      await cache.set(context, content, createCacheConfig(cacheConfig), true);
       const matchContext = {
         entry: "",
         pathname: matchOne.url,
         query: matchOne.query,
         headers: matchOne.headers
       };
-      const cacheResult = yield cache.get(matchContext);
+      const cacheResult = await cache.get(matchContext);
       expect(cacheResult == null ? void 0 : cacheResult.content).toBe(content);
       for (const notMatch of other) {
         const notMatchContext = {
@@ -188,12 +153,12 @@ describe("cache", () => {
           query: notMatch.query,
           headers: notMatch.headers
         };
-        const nothing = yield cache.get(notMatchContext);
+        const nothing = await cache.get(notMatchContext);
         expect(nothing).toBe(null);
       }
     }
-  }));
-  it("should stale cache correctly", () => __async(exports, null, function* () {
+  });
+  it("should stale cache correctly", async () => {
     (0, import_spr.destroyCache)();
     const cache = (0, import_spr.createCache)();
     const context = {
@@ -204,19 +169,19 @@ describe("cache", () => {
     };
     const config = createCacheConfig({ interval: 5 });
     const content = "hello";
-    const shouldCache = yield cache.set(context, content, config, true);
+    const shouldCache = await cache.set(context, content, config, true);
     expect(shouldCache.value).toBe(true);
-    const freshResult = yield cache.get(context);
+    const freshResult = await cache.get(context);
     expect(freshResult == null ? void 0 : freshResult.isStale).toBe(false);
-    yield new Promise((resolve) => {
+    await new Promise((resolve) => {
       setTimeout(() => {
         resolve();
       }, 6e3);
     });
-    const staleResult = yield cache.get(context);
+    const staleResult = await cache.get(context);
     expect(staleResult == null ? void 0 : staleResult.isStale).toBe(true);
-  }));
-  it("should garbage cache correctly", () => __async(exports, null, function* () {
+  });
+  it("should garbage cache correctly", async () => {
     (0, import_spr.destroyCache)();
     const cache = (0, import_spr.createCache)();
     const context = {
@@ -230,16 +195,16 @@ describe("cache", () => {
       staleLimit: 8
     });
     const content = "hello";
-    const shouldCache = yield cache.set(context, content, config, true);
+    const shouldCache = await cache.set(context, content, config, true);
     expect(shouldCache.value).toBe(true);
-    const freshResult = yield cache.get(context);
+    const freshResult = await cache.get(context);
     expect(freshResult == null ? void 0 : freshResult.isGarbage).toBe(false);
-    yield new Promise((resolve) => {
+    await new Promise((resolve) => {
       setTimeout(() => {
         resolve();
       }, 1e4);
     });
-    const staleResult = yield cache.get(context);
+    const staleResult = await cache.get(context);
     expect(staleResult == null ? void 0 : staleResult.isGarbage).toBe(true);
-  }));
+  });
 });

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/{js/node → cjs}/libs/render/cache/spr.js

@@ -21,26 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-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());
-  });
-};
 var spr_exports = {};
 __export(spr_exports, {
   createCache: () => createCache,
@@ -159,15 +139,13 @@ class CacheManager {
     const headerFactor = this.factor(headerKeys, requestHeader, headerMatches);
     return headerFactor;
   }
-  best(context, cacheKey, data) {
-    return __async(this, null, function* () {
-      const { level } = data;
-      const cacheHash = this.find[(0, import_util.fname)(level)](context, cacheKey, data);
-      if (!cacheHash) {
-        return null;
-      }
-      return data.caches.get(cacheHash);
-    });
+  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 {
@@ -179,77 +157,71 @@ class CacheManager {
       caches
     };
   }
-  get(context) {
-    return __async(this, null, function* () {
-      const cacheKey = this.generateRequestKey(context);
-      const data = this.cache.get(cacheKey);
-      if (!data) {
-        return null;
-      }
-      const dest = yield 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 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
+    };
   }
-  set(context, html, cacheConfig, sync = false) {
-    return __async(this, null, function* () {
-      if (!cacheConfig) {
-        return false;
-      }
-      const cacheKey = this.generateRequestKey(context);
-      let data = this.cache.get(cacheKey);
-      if (!data) {
-        const caches = yield (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(this, null, function* () {
-        const next = data;
-        const limit = cacheConfig.staleLimit;
-        const storeHTML = (0, import_util.cacheAddition)(html, cacheHash);
-        const size = storeHTML.length;
-        yield 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;
+  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
       });
-      const doCache = (0, import_util.withCoalescedInvoke)(cacheSyncOrAsync).bind(
-        null,
-        (0, import_util.namespaceHash)("stream", cacheHash),
-        []
-      );
-      return (0, import_util.maybeSync)(doCache)(sync);
-    });
+      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);
   }
-  del(context, cacheHash) {
-    return __async(this, null, function* () {
-      const cacheKey = this.generateRequestKey(context);
-      const data = this.cache.get(cacheKey);
-      data == null ? void 0 : data.caches.del(cacheHash);
-    });
+  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;

package/dist/{js/node → cjs}/libs/render/cache/util.js

@@ -21,26 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-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());
-  });
-};
 var util_exports = {};
 __export(util_exports, {
   cacheAddition: () => cacheAddition,
@@ -91,28 +71,26 @@ function cacheAddition(html, hash) {
 }
 const globalInvokeCache = /* @__PURE__ */ new Map();
 function withCoalescedInvoke(func) {
-  return function(key, args) {
-    return __async(this, null, function* () {
-      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;
+  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) {