@modern-js/prod-server 2.4.0 → 2.5.0

package/dist/esm-node/libs/render/cache/__tests__/cache.test.js

@@ -0,0 +1,210 @@
+import { createCache, destroyCache } from "../spr";
+import { errorConfiguration } from "./error-configuration";
+import { cacheabelAry } from "./cacheable";
+import { matchedCacheableAry } from "./matched-cache";
+const createCacheConfig = (config = {}) => ({
+  excludes: null,
+  includes: null,
+  interval: 10,
+  staleLimit: false,
+  level: 0,
+  fallback: false,
+  matches: null,
+  ...config
+});
+jest.setTimeout(6e4);
+describe("cache", () => {
+  it("should cache correctly", async () => {
+    destroyCache();
+    const cache = createCache();
+    const context = {
+      entry: "",
+      pathname: "",
+      query: {},
+      headers: {}
+    };
+    const content = "hello";
+    const cacheConfig = createCacheConfig();
+    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 () => {
+    destroyCache();
+    destroyCache();
+    const cache = createCache();
+    const context = {
+      entry: "",
+      pathname: "",
+      query: {},
+      headers: {}
+    };
+    const content = "hello";
+    const shouldCache = await cache.set(context, content, null, true);
+    expect(shouldCache).toBe(false);
+  });
+  it("should calcual cache key error", async () => {
+    destroyCache();
+    const cache = createCache();
+    const content = "hello";
+    for (const config of errorConfiguration) {
+      const cacheConfig = createCacheConfig(config);
+      const tmpEntry = Math.random().toString();
+      const context = {
+        entry: tmpEntry,
+        pathname: "",
+        query: {},
+        headers: {}
+      };
+      const shouldCache = await cache.set(context, content, cacheConfig);
+      expect(shouldCache).toBe(false);
+    }
+  });
+  it("should get nothing for diff requestKey", async () => {
+    destroyCache();
+    const cache = createCache();
+    const context = {
+      entry: "",
+      pathname: "",
+      query: {},
+      headers: {}
+    };
+    const content = "hello";
+    const cacheConfig = createCacheConfig({
+      level: 1,
+      includes: { query: ["name"] }
+    });
+    await cache.set(context, content, cacheConfig, true);
+    const context_req = {
+      entry: "",
+      pathname: "/home",
+      query: {},
+      headers: {}
+    };
+    const cacheResult = await cache.get(context_req);
+    expect(cacheResult).toBe(null);
+  });
+  it("should get nothing for diff cacheHash", async () => {
+    destroyCache();
+    const cache = createCache();
+    const context = {
+      entry: "",
+      pathname: "",
+      query: {},
+      headers: {}
+    };
+    const content = "hello";
+    const cacheConfig = createCacheConfig({
+      level: 1,
+      includes: { query: ["name"] }
+    });
+    await cache.set(context, content, cacheConfig, true);
+    const context_req = {
+      entry: "",
+      pathname: "",
+      query: { name: "zll" },
+      headers: {}
+    };
+    const cacheResult = await cache.get(context_req);
+    expect(cacheResult).toBe(null);
+  });
+  it("should get cache correctly", async () => {
+    destroyCache();
+    const cache = createCache();
+    for (const cacheable of cacheabelAry) {
+      const context = {
+        entry: "",
+        pathname: cacheable.requestOpt.url,
+        query: cacheable.requestOpt.query || {},
+        headers: cacheable.requestOpt.headers || {}
+      };
+      const cacheConfig = createCacheConfig(cacheable.cacheConfig || {});
+      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 () => {
+    destroyCache();
+    const cache = createCache();
+    for (const cacheable of matchedCacheableAry) {
+      const [baseCacheable, matchOne, ...other] = cacheable;
+      const { requestOpt = {}, cacheConfig, content } = baseCacheable;
+      const context = {
+        entry: "",
+        pathname: requestOpt.url,
+        query: requestOpt.query,
+        headers: requestOpt.headers
+      };
+      await cache.set(context, content, createCacheConfig(cacheConfig), true);
+      const matchContext = {
+        entry: "",
+        pathname: matchOne.url,
+        query: matchOne.query,
+        headers: matchOne.headers
+      };
+      const cacheResult = await cache.get(matchContext);
+      expect(cacheResult == null ? void 0 : cacheResult.content).toBe(content);
+      for (const notMatch of other) {
+        const notMatchContext = {
+          entry: "",
+          pathname: notMatch.url,
+          query: notMatch.query,
+          headers: notMatch.headers
+        };
+        const nothing = await cache.get(notMatchContext);
+        expect(nothing).toBe(null);
+      }
+    }
+  });
+  it("should stale cache correctly", async () => {
+    destroyCache();
+    const cache = createCache();
+    const context = {
+      entry: "",
+      pathname: "",
+      query: {},
+      headers: {}
+    };
+    const config = createCacheConfig({ interval: 5 });
+    const content = "hello";
+    const shouldCache = await cache.set(context, content, config, true);
+    expect(shouldCache.value).toBe(true);
+    const freshResult = await cache.get(context);
+    expect(freshResult == null ? void 0 : freshResult.isStale).toBe(false);
+    await new Promise((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, 6e3);
+    });
+    const staleResult = await cache.get(context);
+    expect(staleResult == null ? void 0 : staleResult.isStale).toBe(true);
+  });
+  it("should garbage cache correctly", async () => {
+    destroyCache();
+    const cache = createCache();
+    const context = {
+      entry: "",
+      pathname: "",
+      query: {},
+      headers: {}
+    };
+    const config = createCacheConfig({
+      interval: 3,
+      staleLimit: 8
+    });
+    const content = "hello";
+    const shouldCache = await cache.set(context, content, config, true);
+    expect(shouldCache.value).toBe(true);
+    const freshResult = await cache.get(context);
+    expect(freshResult == null ? void 0 : freshResult.isGarbage).toBe(false);
+    await new Promise((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, 1e4);
+    });
+    const staleResult = await cache.get(context);
+    expect(staleResult == null ? void 0 : staleResult.isGarbage).toBe(true);
+  });
+});

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

@@ -0,0 +1,76 @@
+import { Transform } from "stream";
+import { ERROR_DIGEST } from "../../../constants";
+import { createCache } from "./spr";
+import { namespaceHash, withCoalescedInvoke } from "./util";
+var cache_default = (renderFn, ctx) => {
+  const sprCache = 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 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 = withCoalescedInvoke(() => renderFn(context)).bind(
+        null,
+        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(ERROR_DIGEST.ERENDER, e);
+      });
+    }
+    ctx.res.setHeader("x-modern-spr", "1");
+    return cacheFile.content;
+  };
+  return doRender;
+};
+export {
+  cache_default as default
+};

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

@@ -0,0 +1,10 @@
+import { LRUCaches } from "./lru";
+async function createPageCaches(max) {
+  const constructorOptions = { max };
+  const cacheInstance = new LRUCaches(constructorOptions);
+  await cacheInstance.init();
+  return cacheInstance;
+}
+export {
+  createPageCaches
+};

package/dist/{js/modern → esm-node}/libs/render/cache/spr.js

@@ -1,23 +1,3 @@
-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 crypto from "crypto";
 import LRUCache from "lru-cache";
 import { mime } from "@modern-js/utils";
@@ -138,15 +118,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[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[fname(level)](context, cacheKey, data);
+    if (!cacheHash) {
+      return null;
+    }
+    return data.caches.get(cacheHash);
   }
   createCacheContent(config, caches) {
     return {
@@ -158,77 +136,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: 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: 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 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(this, null, function* () {
-        const next = data;
-        const limit = cacheConfig.staleLimit;
-        const storeHTML = 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 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
       });
-      const doCache = withCoalescedInvoke(cacheSyncOrAsync).bind(
-        null,
-        namespaceHash("stream", cacheHash),
-        []
-      );
-      return maybeSync(doCache)(sync);
-    });
+      this.cache.set(cacheKey, next);
+      return true;
+    };
+    const doCache = withCoalescedInvoke(cacheSyncOrAsync).bind(
+      null,
+      namespaceHash("stream", cacheHash),
+      []
+    );
+    return 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/modern → esm-node}/libs/render/cache/util.js

@@ -1,23 +1,3 @@
-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 url from "url";
 function namespaceHash(namespace, hash) {
   return `${namespace}/${hash}`;
@@ -56,28 +36,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) {

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/{js/modern → esm-node}/libs/render/measure.js

@@ -1,37 +1,20 @@
-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));
 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, __spreadProps(__spreadValues({}, tags), {
+    metrics.emitTimer(name, cost, {
+      ...tags,
       pathname,
       entry
-    }));
+    });
   };
   const emitCounter = (name, counter, tags = {}) => {
-    metrics.emitCounter(name, counter, __spreadProps(__spreadValues({}, tags), {
+    metrics.emitCounter(name, counter, {
+      ...tags,
       pathname,
       entry
-    }));
+    });
   };
   return { emitTimer, emitCounter };
 };