@modern-js/server 1.4.3 → 1.4.5

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

@@ -1,280 +0,0 @@
-/* eslint-disable @typescript-eslint/member-ordering */
-
-/* eslint-disable no-lone-blocks */
-import crypto from 'crypto';
-import LRUCache from 'lru-cache';
-import mime from 'mime-types';
-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.cache = void 0;
-    this.cacheOptions = void 0;
-
-    this.find = (() => {
-      {
-        // eslint-disable-next-line consistent-this,@typescript-eslint/no-this-alias
-        const _this = this;
-
-        return {
-          [fname(BASE_LEVEL)](context, cacheKey // data: CacheContent,
-          ) {
-            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 _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;
-      }
-
-    });
-  }
-
-  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 _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;
-    }
-
-    const requestQuery = context.query;
-    const queryFactor = this.factor(queryKeys, requestQuery, queryMatches);
-    return queryFactor;
-  }
-
-  headerFactor(context, data) {
-    var _data$includes2, _data$matches2;
-
-    const headerKeys = (_data$includes2 = data.includes) === null || _data$includes2 === void 0 ? void 0 : _data$includes2.header;
-    const headerMatches = (_data$matches2 = data.matches) === null || _data$matches2 === void 0 ? void 0 : _data$matches2.header;
-
-    if (!headerKeys || headerKeys.length === 0) {
-      return null;
-    }
-
-    const requestHeader = context.headers;
-    const headerFactor = this.factor(headerKeys, requestHeader, headerMatches);
-    return headerFactor;
-  }
-
-  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 {
-      level: config.level,
-      interval: config.interval,
-      includes: config.includes || null,
-      limit: config.staleLimit,
-      matches: config.matches || null,
-      caches
-    };
-  }
-
-  async get(context) {
-    const cacheKey = this.generateRequestKey(context);
-    const data = this.cache.get(cacheKey); // no cache key matched
-
-    if (!data) {
-      return null;
-    }
-
-    const dest = await this.best(context, cacheKey, data); // no cache for current page with current config
-
-    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 set(context, html, cacheConfig, sync = false) {
-    if (!cacheConfig) {
-      return false;
-    } // each version with route is a separate cache
-
-
-    const cacheKey = this.generateRequestKey(context);
-    let data = this.cache.get(cacheKey);
-
-    if (!data) {
-      const caches = await createPageCaches(MAX_CACHE_EACH_REQ); // eslint-disable-next-line require-atomic-updates
-
-      data = this.createCacheContent(cacheConfig, caches);
-    }
-
-    const cacheHash = this.find[fname(cacheConfig.level)](context, cacheKey, data); // if cacheHash is null, maybe level not match meta key, do not cache
-
-    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 * 1000,
-        limitTime: typeof limit === 'number' ? Date.now() + limit * 1000 : null,
-        cacheHash,
-        html: storeHTML,
-        size
-      });
-      this.cache.set(cacheKey, next);
-      return true;
-    }; // cache set is async, each hash is cached only once at the same time
-
-
-    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 || data === void 0 ? void 0 : data.caches.del(cacheHash);
-  }
-
-}
-
-let manager;
-export function createCache() {
-  if (manager) {
-    return manager;
-  }
-
-  manager = new CacheManager({
-    max: 0
-  });
-  return manager;
-}
-export function destroyCache() {
-  manager = null;
-}
-/* eslint-enable no-lone-blocks */
-
-/* eslint-enable @typescript-eslint/member-ordering */

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

@@ -1,79 +0,0 @@
-import url from 'url';
-export function namespaceHash(namespace, hash) {
-  return `${namespace}/${hash}`;
-}
-export function fname(lv) {
-  return `f${lv}`;
-}
-export function connectFactor(...args) {
-  return args.join('-');
-}
-export 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;
-    };
-  }
-}
-export function getTime([s, ns]) {
-  return Math.floor(s * 1e3 + ns / 1e6);
-}
-const RE_START_IN_HEAD = /<head>/;
-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 = new Map();
-export function withCoalescedInvoke(func) {
-  return async function (key, args) {
-    const entry = globalInvokeCache.get(key);
-
-    if (entry) {
-      // eslint-disable-next-line promise/prefer-await-to-then
-      return entry.then(res => ({
-        isOrigin: false,
-        value: res.value
-      }));
-    }
-
-    function __wrapper() {
-      return func(...args);
-    }
-
-    const future = __wrapper() // eslint-disable-next-line promise/prefer-await-to-then
-    .then(res => {
-      globalInvokeCache.delete(key);
-      return {
-        isOrigin: true,
-        value: res
-      };
-    }) // eslint-disable-next-line promise/prefer-await-to-then
-    .catch(err => {
-      globalInvokeCache.delete(key);
-      throw err;
-    });
-
-    globalInvokeCache.set(key, future);
-    return future;
-  };
-}
-export function maybeSync(fn) {
-  return sync => {
-    if (sync) {
-      return fn();
-    } else {
-      fn();
-      return Promise.resolve();
-    }
-  };
-}

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

@@ -1,65 +0,0 @@
-import path from 'path';
-import { fs } from '@modern-js/utils';
-import mime from 'mime-types';
-import { ERROR_DIGEST } from "../../constants";
-import { handleDirectory } from "./static";
-import { readFile } from "./reader";
-import * as ssr from "./ssr";
-import { supportModern, getModernEntry } from "./modern";
-export const createRenderHandler = ({
-  distDir,
-  staticGenerate
-}) => 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;
-  } // only spa can use es6-html
-
-
-  const modernEntry = getModernEntry(entry);
-  const useModern = // route.enableModernMode &&
-  supportModern(ctx) && fs.existsSync(modernEntry);
-  const templateHTML = useModern ? modernEntry : entry; // handles ssr first
-
-  if (route.isSSR) {
-    try {
-      const result = await ssr.render(ctx, {
-        distDir,
-        entryName: route.entryName,
-        urlPath: route.urlPath,
-        bundle: route.bundle,
-        template: templateHTML,
-        staticGenerate
-      }, runner);
-      return result;
-    } catch (err) {
-      ctx.error(ERROR_DIGEST.ERENDER, err.stack);
-      ctx.res.setHeader('x-modern-ssr-fallback', '1');
-    }
-  }
-
-  const content = await readFile(templateHTML);
-
-  if (!content) {
-    return null;
-  }
-
-  return {
-    content,
-    contentType: mime.contentType(path.extname(templateHTML))
-  };
-};

package/dist/js/modern/libs/render/modern/browser-list.js

@@ -1,7 +0,0 @@
-export const NativeModuleNameMap = {
-  Chrome: 'chrome',
-  'Mobile Safari': 'ios_saf',
-  Safari: 'safari',
-  Edge: 'edge',
-  Firefox: 'firefox'
-};

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

@@ -1,42 +0,0 @@
-import Parser from 'ua-parser-js';
-import compareVersions from 'compare-versions';
-import { NativeModuleNameMap } from "./browser-list";
-
-const nativeModules = require('@babel/compat-data/native-modules');
-
-export const supportModern = context => {
-  if (context.query.modern_es6) {
-    return true;
-  } // no ua in request headers
-
-
-  const userAgent = context.headers['user-agent'];
-
-  if (!userAgent || typeof userAgent !== 'string') {
-    return false;
-  }
-
-  const parsedUA = Parser(userAgent);
-  const browserName = parsedUA.browser.name;
-  const browserVersion = parsedUA.browser.version;
-
-  if (!browserName || !browserVersion) {
-    return false;
-  }
-
-  const nativeUAName = NativeModuleNameMap[browserName];
-
-  if (!nativeUAName) {
-    return false;
-  }
-
-  const version = nativeModules['es6.module'][nativeUAName];
-
-  if (!version) {
-    return false;
-  }
-
-  const result = compareVersions(browserVersion, version);
-  return result >= 0;
-};
-export const getModernEntry = filepath => filepath.replace(/\.html$/, '-es6.html');

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

@@ -1,112 +0,0 @@
-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
-  };
-};
-
-export class LruReader {
-  // private timer?: NodeJS.Timeout;
-  constructor() {
-    this.cache = void 0;
-    this.cache = new LRU({
-      max: 256 * MB,
-      length: getContentLength,
-      maxAge: 5 * 60 * 5000 // 60s
-
-    });
-  }
-
-  init() {// this.timeTask();
-  }
-
-  close() {// if (this.timer) {
-    //   clearInterval(this.timer);
-    // }
-  }
-
-  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 file more than 20 MB
-
-
-    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; // file is modify
-
-        if (item.mtime < mtime) {
-          cache.del(filepath);
-        }
-      } catch (e) {
-        // for safe
-        cache.del(filepath);
-      }
-    }
-  } // private timeTask() {
-  // this.timer = setInterval(() => this.update, 5 * 60 * 1000).unref();
-  // }
-
-
-}
-const reader = new LruReader();
-export const readFile = async filepath => {
-  const file = await reader.read(filepath);
-  return file === null || file === void 0 ? void 0 : file.content;
-};
-export const updateFile = () => {
-  reader.update();
-};
-export const init = () => {
-  reader.init();
-};
-export const close = () => {
-  reader.close();
-};

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

@@ -1,58 +0,0 @@
-import path from 'path';
-import { SERVER_RENDER_FUNCTION_NAME } from '@modern-js/utils';
-import mime from 'mime-types';
-import cookie from 'cookie';
-import cache from "./cache";
-export const render = async (ctx, renderOptions, runner) => {
-  const {
-    urlPath,
-    bundle,
-    distDir,
-    template,
-    entryName,
-    staticGenerate
-  } = renderOptions;
-  const bundleJS = path.join(distDir, bundle);
-  const context = {
-    request: {
-      baseUrl: urlPath,
-      params: ctx.params,
-      pathname: ctx.path,
-      host: ctx.host,
-      query: ctx.query,
-      url: ctx.href,
-      cookieMap: cookie.parse(ctx.headers.cookie || ''),
-      headers: ctx.headers
-    },
-    redirection: {},
-    template,
-    entryName,
-    distDir,
-    staticGenerate,
-    logger: ctx.logger,
-    metrics: ctx.metrics
-  };
-  runner.extendSSRContext(context);
-
-  const serverRender = require(bundleJS)[SERVER_RENDER_FUNCTION_NAME];
-
-  const html = await cache(serverRender, ctx)(context);
-  const {
-    url,
-    status = 302
-  } = context.redirection;
-
-  if (url) {
-    return {
-      content: url,
-      contentType: '',
-      statusCode: status,
-      redirect: true
-    };
-  }
-
-  return {
-    content: html,
-    contentType: mime.contentType('html')
-  };
-};

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

@@ -1,46 +0,0 @@
-import path from 'path';
-import mime from 'mime-types';
-import { readFile } from "./reader";
-export async function handleDirectory(ctx, entryPath, urlPath) {
-  const {
-    path: pathname
-  } = ctx;
-  const filepath = path.join(entryPath, trimLeft(pathname, urlPath)); // If can match accurately, always return the one that matches accurately
-
-  let content = await readFile(filepath);
-  let contentType = mime.contentType(path.extname(filepath) || ''); // automatic addressing
-
-  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`);
-      }
-    } // set content-type as 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;
-};

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

@@ -1,7 +0,0 @@
-export let RenderLevel;
-
-(function (RenderLevel) {
-  RenderLevel[RenderLevel["CLIENT_RENDER"] = 0] = "CLIENT_RENDER";
-  RenderLevel[RenderLevel["SERVER_PREFETCH"] = 1] = "SERVER_PREFETCH";
-  RenderLevel[RenderLevel["SERVER_RENDER"] = 2] = "SERVER_RENDER";
-})(RenderLevel || (RenderLevel = {}));