@modern-js/prod-server 2.6.1-alpha.0 → 2.7.0

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

@@ -1,29 +0,0 @@
-import LRU from "lru-cache";
-class LRUCaches {
-  constructor(options) {
-    this.max = options.max;
-    this.caches = new LRU(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);
-  }
-}
-export {
-  LRUCaches
-};

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

@@ -1,248 +0,0 @@
-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";
-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;
-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 {
-          [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 _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");
-  }
-  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 = 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;
-  }
-  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);
-    });
-  }
-  createCacheContent(config, caches) {
-    return {
-      level: config.level,
-      interval: config.interval,
-      includes: config.includes || null,
-      limit: config.staleLimit,
-      matches: config.matches || null,
-      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
-      };
-    });
-  }
-  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;
-      });
-      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);
-    });
-  }
-}
-let manager;
-function createCache() {
-  if (manager) {
-    return manager;
-  }
-  manager = new CacheManager({ max: 0 });
-  return manager;
-}
-function destroyCache() {
-  manager = null;
-}
-export {
-  createCache,
-  destroyCache
-};

package/dist/js/modern/libs/render/cache/util.js

@@ -1,102 +0,0 @@
-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}`;
-}
-function fname(lv) {
-  return `f${lv}`;
-}
-function connectFactor(...args) {
-  return args.join("-");
-}
-function valueFactory(obj) {
-  if (obj instanceof url.URLSearchParams) {
-    return function(key) {
-      return obj.get(key);
-    };
-  } else {
-    return function(key) {
-      const value = obj[key];
-      if (Array.isArray(value)) {
-        return value.join(",");
-      }
-      return value;
-    };
-  }
-}
-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}">`
-  );
-  return additionHtml;
-}
-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;
-    });
-  };
-}
-function maybeSync(fn) {
-  return (sync) => {
-    if (sync) {
-      return fn();
-    } else {
-      fn();
-      return Promise.resolve();
-    }
-  };
-}
-export {
-  cacheAddition,
-  connectFactor,
-  fname,
-  getTime,
-  maybeSync,
-  namespaceHash,
-  valueFactory,
-  withCoalescedInvoke
-};

package/dist/js/modern/libs/render/index.js

@@ -1,86 +0,0 @@
-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, 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
-}) => function render(_0) {
-  return __async(this, arguments, function* ({
-    ctx,
-    route,
-    runner
-  }) {
-    if (ctx.resHasHandled()) {
-      return null;
-    }
-    const { entryPath, urlPath } = route;
-    const entry = path.join(distDir, entryPath);
-    if (!route.isSPA) {
-      const result = yield handleDirectory(ctx, entry, urlPath);
-      return result;
-    }
-    const templatePath = entry;
-    if (!fs.existsSync(templatePath)) {
-      throw new Error(`Could not find template file: ${templatePath}`);
-    }
-    const content = yield readFile(templatePath);
-    if (!content) {
-      return null;
-    }
-    const useCSR = forceCSR && ctx.query.csr;
-    if (route.isSSR && !useCSR) {
-      try {
-        const result = yield 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/libs/render/measure.js

@@ -1,68 +0,0 @@
-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), {
-      pathname,
-      entry
-    }));
-  };
-  const emitCounter = (name, counter, tags = {}) => {
-    metrics.emitCounter(name, counter, __spreadProps(__spreadValues({}, tags), {
-      pathname,
-      entry
-    }));
-  };
-  return { emitTimer, emitCounter };
-};
-const createLogger = (serverContext, logger) => {
-  const request = serverContext.request || {};
-  const { headers = {}, pathname = "" } = request;
-  const debug = (message, ...args) => {
-    logger.debug(`SSR Debug - ${message}, req.url = %s`, ...args, pathname);
-  };
-  const info = (message, ...args) => {
-    logger.info(`SSR Info - ${message}, req.url = %s`, ...args, pathname);
-  };
-  const error = (message, e) => {
-    if (!e) {
-      e = message;
-      message = "";
-    }
-    logger.error(
-      `SSR Error - ${message}, error = %s, req.url = %s, req.headers = %o`,
-      e instanceof Error ? e.stack || e.message : e,
-      pathname,
-      headersWithoutCookie(headers)
-    );
-  };
-  return {
-    error,
-    info,
-    debug
-  };
-};
-export {
-  createLogger,
-  createMetrics
-};

package/dist/js/modern/libs/render/reader.js

@@ -1,107 +0,0 @@
-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 { 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 = (filepath, mtime) => __async(void 0, null, function* () {
-  const content = yield fs.readFile(filepath);
-  return {
-    content,
-    mtime
-  };
-});
-class LruReader {
-  constructor() {
-    this.cache = new LRU({
-      max: 256 * MB,
-      length: getContentLength,
-      maxAge: 5 * 60 * 5e3
-    });
-  }
-  init() {
-  }
-  close() {
-  }
-  read(filepath) {
-    return __async(this, null, function* () {
-      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 = yield 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 = (filepath) => __async(void 0, null, function* () {
-  const file = yield 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
-};