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

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 };
 };

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/{js/modern → esm-node}/libs/render/ssr.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 path from "path";
 import {
   fs,
@@ -29,7 +9,7 @@ import {
 import cookie from "cookie";
 import cache from "./cache";
 import { createLogger, createMetrics } from "./measure";
-const render = (ctx, renderOptions, runner) => __async(void 0, null, function* () {
+const render = async (ctx, renderOptions, runner) => {
   var _a;
   const { urlPath, bundle, distDir, template, entryName, staticGenerate } = renderOptions;
   const bundleJS = path.join(distDir, bundle);
@@ -72,7 +52,7 @@ const render = (ctx, renderOptions, runner) => __async(void 0, null, function* (
   context.metrics = createMetrics(context, ctx.metrics);
   runner.extendSSRContext(context);
   const serverRender = require(bundleJS)[SERVER_RENDER_FUNCTION_NAME];
-  const content = yield cache(serverRender, ctx)(context);
+  const content = await cache(serverRender, ctx)(context);
   const { url, status = 302 } = context.redirection;
   if (url) {
     return {
@@ -94,7 +74,7 @@ const render = (ctx, renderOptions, runner) => __async(void 0, null, function* (
       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/{js/modern → esm-node}/libs/serve-file.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 serve from "serve-static";
 import { isString, isRegExp } from "@modern-js/utils";
 import { useLocalPrefix } from "../utils";
@@ -40,7 +20,7 @@ const faviconFallbackHandler = (context, next) => {
     next();
   }
 };
-const createStaticFileHandler = (rules, output = {}) => (context, next) => __async(void 0, null, function* () {
+const createStaticFileHandler = (rules, output = {}) => async (context, next) => {
   const { url: requestUrl, req, res } = context;
   const { assetPrefix = "/" } = output;
   const hitRule = rules.find((item) => {
@@ -60,7 +40,7 @@ const createStaticFileHandler = (rules, output = {}) => (context, next) => __asy
   } else {
     return next();
   }
-});
+};
 export {
   createStaticFileHandler,
   faviconFallbackHandler