@modern-js/prod-server 2.14.0 → 2.16.0

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

@@ -1,12 +1,16 @@
-const errorConfiguration = [
-  { level: 1 },
+export const errorConfiguration = [
+  {
+    level: 1
+  },
   {
     level: 1,
     includes: {}
   },
   {
     level: 1,
-    includes: { query: [] }
+    includes: {
+      query: []
+    }
   },
   {
     level: 2,
@@ -14,15 +18,21 @@ const errorConfiguration = [
   },
   {
     level: 2,
-    includes: { header: [] }
+    includes: {
+      header: []
+    }
   },
   {
     level: 3,
-    includes: { header: [] }
+    includes: {
+      header: []
+    }
   },
   {
     level: 3,
-    includes: { query: [] }
+    includes: {
+      query: []
+    }
   },
   {
     level: 3,
@@ -32,6 +42,3 @@ const errorConfiguration = [
     }
   }
 ];
-export {
-  errorConfiguration
-};

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

@@ -1,27 +1,43 @@
-const matchedCacheableAry = [
+export const matchedCacheableAry = [
   [
     {
       requestOpt: {
         url: "/level-one",
         headers: {},
-        query: { name: "byted" }
+        query: {
+          name: "byted"
+        }
       },
       cacheConfig: {
         level: 1,
-        includes: { query: ["name"] },
-        matches: { query: { name: { weixin: "^byted" } } }
+        includes: {
+          query: [
+            "name"
+          ]
+        },
+        matches: {
+          query: {
+            name: {
+              weixin: "^byted"
+            }
+          }
+        }
       },
       content: "level1"
     },
     {
       url: "/level-one",
       headers: {},
-      query: { name: "byted_likely" }
+      query: {
+        name: "byted_likely"
+      }
     },
     {
       url: "/level-one",
       headers: {},
-      query: { name: "not_byted" }
+      query: {
+        name: "not_byted"
+      }
     }
   ],
   [
@@ -29,63 +45,102 @@ const matchedCacheableAry = [
       requestOpt: {
         url: "/level-two",
         query: {},
-        headers: { age: "17" }
+        headers: {
+          age: "17"
+        }
       },
       cacheConfig: {
         level: 2,
-        includes: { header: ["age"] },
-        matches: { header: { age: { one: "^1" } } }
+        includes: {
+          header: [
+            "age"
+          ]
+        },
+        matches: {
+          header: {
+            age: {
+              one: "^1"
+            }
+          }
+        }
       },
       content: "level2"
     },
     {
       url: "/level-two",
       query: {},
-      headers: { age: "11" }
+      headers: {
+        age: "11"
+      }
     },
     {
       url: "/level-two",
       query: {},
-      headers: { age: "22" }
+      headers: {
+        age: "22"
+      }
     }
   ],
   [
     {
       requestOpt: {
         url: "/level-three",
-        headers: { age: "17" },
-        query: { name: "byted" }
+        headers: {
+          age: "17"
+        },
+        query: {
+          name: "byted"
+        }
       },
       cacheConfig: {
         level: 3,
         includes: {
-          query: ["name"],
-          header: ["age"]
+          query: [
+            "name"
+          ],
+          header: [
+            "age"
+          ]
         },
         matches: {
-          query: { name: { weixin: "^byted" } },
-          header: { age: { one: "^1" } }
+          query: {
+            name: {
+              weixin: "^byted"
+            }
+          },
+          header: {
+            age: {
+              one: "^1"
+            }
+          }
         }
       },
       content: "level3"
     },
     {
       url: "/level-three",
-      query: { name: "byted_likely" },
-      headers: { age: "19" }
+      query: {
+        name: "byted_likely"
+      },
+      headers: {
+        age: "19"
+      }
     },
     {
       url: "/level-three",
-      query: { name: "byted_likely" },
+      query: {
+        name: "byted_likely"
+      },
       headers: {}
     },
     {
       url: "/level-three",
-      query: { name: "not_byted" },
-      headers: { age: "19" }
+      query: {
+        name: "not_byted"
+      },
+      headers: {
+        age: "19"
+      }
     }
   ]
 ];
-export {
-  matchedCacheableAry
-};

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

@@ -2,7 +2,7 @@ import { Transform } from "stream";
 import { ERROR_DIGEST } from "../../../constants";
 import { createCache } from "./spr";
 import { namespaceHash, withCoalescedInvoke } from "./util";
-var cache_default = (renderFn, ctx) => {
+export default (renderFn, ctx) => {
   const sprCache = createCache();
   const doRender = async (context) => {
     const cacheContext = {
@@ -40,16 +40,12 @@ var cache_default = (renderFn, ctx) => {
       const renderResult = await renderFn(context);
       return afterRender(renderResult, saveHtmlIntoCache);
     }
-    const cacheHash = cacheFile == null ? void 0 : cacheFile.hash;
+    const cacheHash = cacheFile === null || cacheFile === void 0 ? 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),
-        []
-      );
+      const render = withCoalescedInvoke(() => renderFn(context)).bind(null, namespaceHash("render", cacheFile.hash), []);
       render().then(async (res) => {
         if (res.value && res.isOrigin) {
           const { cacheConfig } = context;
@@ -71,6 +67,3 @@ var cache_default = (renderFn, ctx) => {
   };
   return doRender;
 };
-export {
-  cache_default as default
-};

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

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

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

@@ -1,9 +1,18 @@
-import LRU from "lru-cache";
-class LRUCaches {
-  constructor(options) {
-    this.max = options.max;
-    this.caches = new LRU(this.max);
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
   }
+  return obj;
+}
+import LRU from "lru-cache";
+export class LRUCaches {
   init() {
     return Promise.resolve();
   }
@@ -23,7 +32,10 @@ class LRUCaches {
   del(key) {
     this.caches.del(key);
   }
+  constructor(options) {
+    _define_property(this, "caches", void 0);
+    _define_property(this, "max", void 0);
+    this.max = options.max;
+    this.caches = new LRU(this.max);
+  }
 }
-export {
-  LRUCaches
-};

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

@@ -1,15 +1,20 @@
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 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 { 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;
@@ -18,52 +23,6 @@ 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,
-      // 默认存 100M，最大 600M
-      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");
@@ -93,14 +52,17 @@ class CacheManager {
       if (matcher) {
         value = this.replaceValue(value, matcher);
       }
-      return ary.concat([key, value]);
+      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;
+    var _data_includes, _data_matches;
+    const queryKeys = (_data_includes = data.includes) === null || _data_includes === void 0 ? void 0 : _data_includes.query;
+    const queryMatches = (_data_matches = data.matches) === null || _data_matches === void 0 ? void 0 : _data_matches.query;
     if (!queryKeys || queryKeys.length === 0) {
       return null;
     }
@@ -109,9 +71,9 @@ class CacheManager {
     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;
+    var _data_includes, _data_matches;
+    const headerKeys = (_data_includes = data.includes) === null || _data_includes === void 0 ? void 0 : _data_includes.header;
+    const headerMatches = (_data_matches = data.matches) === null || _data_matches === void 0 ? void 0 : _data_matches.header;
     if (!headerKeys || headerKeys.length === 0) {
       return null;
     }
@@ -168,11 +130,7 @@ class CacheManager {
       const caches = await createPageCaches(MAX_CACHE_EACH_REQ);
       data = this.createCacheContent(cacheConfig, caches);
     }
-    const cacheHash = this.find[fname(cacheConfig.level)](
-      context,
-      cacheKey,
-      data
-    );
+    const cacheHash = this.find[fname(cacheConfig.level)](context, cacheKey, data);
     if (!cacheHash) {
       return false;
     }
@@ -191,31 +149,72 @@ class CacheManager {
       this.cache.set(cacheKey, next);
       return true;
     };
-    const doCache = withCoalescedInvoke(cacheSyncOrAsync).bind(
-      null,
-      namespaceHash("stream", cacheHash),
-      []
-    );
+    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);
+    data === null || data === void 0 ? void 0 : data.caches.del(cacheHash);
+  }
+  constructor(cacheOptions) {
+    _define_property(this, "cache", void 0);
+    _define_property(this, "cacheOptions", void 0);
+    _define_property(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 _n_caches_peek;
+          return total + (((_n_caches_peek = n.caches.peek(cur)) === null || _n_caches_peek === void 0 ? void 0 : _n_caches_peek.size) || 0);
+        }, 1);
+        return len;
+      }
+    });
   }
 }
 let manager;
-function createCache() {
+export function createCache() {
   if (manager) {
     return manager;
   }
-  manager = new CacheManager({ max: 0 });
+  manager = new CacheManager({
+    max: 0
+  });
   return manager;
 }
-function destroyCache() {
+export function destroyCache() {
   manager = null;
 }
-export {
-  createCache,
-  destroyCache
-};

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,14 +1,14 @@
 import url from "url";
-function namespaceHash(namespace, hash) {
+export function namespaceHash(namespace, hash) {
   return `${namespace}/${hash}`;
 }
-function fname(lv) {
+export function fname(lv) {
   return `f${lv}`;
 }
-function connectFactor(...args) {
+export function connectFactor(...args) {
   return args.join("-");
 }
-function valueFactory(obj) {
+export function valueFactory(obj) {
   if (obj instanceof url.URLSearchParams) {
     return function(key) {
       return obj.get(key);
@@ -23,19 +23,16 @@ function valueFactory(obj) {
     };
   }
 }
-function getTime([s, ns]) {
+export 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}">`
-  );
+export 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) {
+export function withCoalescedInvoke(func) {
   return async function(key, args) {
     const entry = globalInvokeCache.get(key);
     if (entry) {
@@ -49,7 +46,10 @@ function withCoalescedInvoke(func) {
     }
     const future = __wrapper().then((res) => {
       globalInvokeCache.delete(key);
-      return { isOrigin: true, value: res };
+      return {
+        isOrigin: true,
+        value: res
+      };
     }).catch((err) => {
       globalInvokeCache.delete(key);
       throw err;
@@ -58,7 +58,7 @@ function withCoalescedInvoke(func) {
     return future;
   };
 }
-function maybeSync(fn) {
+export function maybeSync(fn) {
   return (sync) => {
     if (sync) {
       return fn();
@@ -68,13 +68,3 @@ function maybeSync(fn) {
     }
   };
 }
-export {
-  cacheAddition,
-  connectFactor,
-  fname,
-  getTime,
-  maybeSync,
-  namespaceHash,
-  valueFactory,
-  withCoalescedInvoke
-};

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

@@ -5,15 +5,7 @@ import { handleDirectory } from "./static";
 import { readFile } from "./reader";
 import * as ssr from "./ssr";
 import { injectServerData } from "./utils";
-const createRenderHandler = ({
-  distDir,
-  staticGenerate,
-  forceCSR
-}) => async function render({
-  ctx,
-  route,
-  runner
-}) {
+export const createRenderHandler = ({ distDir, staticGenerate, forceCSR }) => async function render({ ctx, route, runner }) {
   if (ctx.resHasHandled()) {
     return null;
   }
@@ -34,24 +26,17 @@ const createRenderHandler = ({
   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
-      );
+      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.error(ERROR_DIGEST.ERENDER, err.stack || err.message);
       ctx.res.setHeader("x-modern-ssr-fallback", "1");
     }
   }
@@ -60,6 +45,3 @@ const createRenderHandler = ({
     contentType: mime.contentType(path.extname(templatePath))
   };
 };
-export {
-  createRenderHandler
-};