@modern-js/server 1.3.1-beta.0 → 1.4.1

package/src/libs/render/cache/page-caches/lru.ts

@@ -1,38 +0,0 @@
-import LRU from 'lru-cache';
-import { PageCache, PageCachesInterface } from '../type';
-
-export class LRUCaches implements PageCachesInterface {
-  caches: LRU<string, PageCache>;
-
-  private readonly max: number;
-
-  constructor(options: { max: number }) {
-    this.max = options.max;
-    this.caches = new LRU(this.max);
-  }
-
-  init() {
-    return Promise.resolve();
-  }
-
-  public keys(): string[] {
-    return this.caches.keys();
-  }
-
-  public get(key: string) {
-    return Promise.resolve(this.caches.get(key) || null);
-  }
-
-  public peek(key: string) {
-    return this.caches.peek(key) || null;
-  }
-
-  public set(key: string, cache: PageCache) {
-    this.caches.set(key, cache);
-    return Promise.resolve();
-  }
-
-  public del(key: string) {
-    this.caches.del(key);
-  }
-}

package/src/libs/render/cache/spr.ts

@@ -1,301 +0,0 @@
-/* eslint-disable @typescript-eslint/member-ordering */
-/* eslint-disable no-lone-blocks */
-import crypto from 'crypto';
-import { IncomingHttpHeaders } from 'http';
-import url from 'url';
-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';
-import {
-  PageCache,
-  PageCachesInterface,
-  CacheContent,
-  CacheManagerOptions,
-  CacheResult,
-  CacheContext,
-  CacheConfig,
-} from './type';
-
-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 {
-  cache: LRUCache<string, CacheContent>;
-
-  cacheOptions: CacheManagerOptions;
-
-  constructor(cacheOptions: CacheManagerOptions) {
-    this.cacheOptions = cacheOptions;
-
-    this.cache = new LRUCache({
-      max: Math.min(MAX_SIZE_EACH_CLUSTER, 600) * 1024 * 1024, // 默认存 100M，最大 600M
-      length(n: CacheContent) {
-        const len = n.caches
-          .keys()
-          .reduce((total, cur) => total + (n.caches.peek(cur)?.size || 0), 1);
-        return len;
-      },
-    });
-  }
-
-  private md5(content: string) {
-    const md5 = crypto.createHash('md5');
-    return md5.update(content).digest('hex');
-  }
-
-  private generateRequestKey(context: CacheContext) {
-    const { pathname, entry } = context;
-    return this.md5(`${pathname}_${entry}`);
-  }
-
-  private replaceValue(value: string, matcher: Record<string, string>) {
-    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;
-  }
-
-  private factor(
-    keys: string[],
-    obj: url.URLSearchParams | IncomingHttpHeaders,
-    matches: Record<string, Record<string, string>> = {},
-  ) {
-    keys.sort();
-    const getValue = valueFactory(obj);
-
-    const factorAry = keys.reduce((ary: string[], key: string) => {
-      let value: string = getValue(key) || '';
-      const matcher = matches[key];
-      if (matcher) {
-        value = this.replaceValue(value, matcher);
-      }
-
-      return ary.concat([key, value]);
-    }, []);
-    return factorAry.join(',');
-  }
-
-  private queryFactor(context: CacheContext, data: CacheContent) {
-    const queryKeys = data.includes?.query;
-    const queryMatches = data.matches?.query;
-    if (!queryKeys || queryKeys.length === 0) {
-      return null;
-    }
-    const requestQuery: any = context.query;
-    const queryFactor = this.factor(queryKeys, requestQuery, queryMatches);
-    return queryFactor;
-  }
-
-  private headerFactor(context: CacheContext, data: CacheContent) {
-    const headerKeys = data.includes?.header;
-    const headerMatches = data.matches?.header;
-    if (!headerKeys || headerKeys.length === 0) {
-      return null;
-    }
-    const requestHeader: any = context.headers;
-    const headerFactor = this.factor(headerKeys, requestHeader, headerMatches);
-    return headerFactor;
-  }
-
-  private readonly find: any = (() => {
-    {
-      // eslint-disable-next-line consistent-this,@typescript-eslint/no-this-alias
-      const _this = this;
-      return {
-        [fname(BASE_LEVEL)](
-          context: CacheContext,
-          cacheKey: string,
-          // data: CacheContent,
-        ): string | null {
-          return _this.md5(cacheKey);
-        },
-        [fname(QUERY_LEVEL)](
-          context: CacheContext,
-          cacheKey: string,
-          data: CacheContent,
-        ): string | null {
-          const queryFactor = _this.queryFactor(context, data);
-          if (!queryFactor) {
-            return null;
-          }
-          return _this.md5(connectFactor(cacheKey, queryFactor));
-        },
-        [fname(HEADER_LEVEL)](
-          context: CacheContext,
-          cacheKey: string,
-          data: CacheContent,
-        ): string | null {
-          const headerFactor = _this.headerFactor(context, data);
-          if (!headerFactor) {
-            return null;
-          }
-          return _this.md5(connectFactor(cacheKey, headerFactor));
-        },
-        [fname(QUERY_HEADER_LEVEL)](
-          context: CacheContext,
-          cacheKey: string,
-          data: CacheContent,
-        ): string | null {
-          const queryFactor = _this.queryFactor(context, data);
-          const headerFactor = _this.headerFactor(context, data);
-          if (!queryFactor || !headerFactor) {
-            return null;
-          }
-          return _this.md5(connectFactor(cacheKey, headerFactor, queryFactor));
-        },
-      };
-    }
-  })();
-
-  private async best(
-    context: CacheContext,
-    cacheKey: string,
-    data: CacheContent,
-  ): Promise<PageCache | null> {
-    const { level } = data;
-    const cacheHash = this.find[fname(level)](context, cacheKey, data);
-    if (!cacheHash) {
-      return null;
-    }
-    return data.caches.get(cacheHash);
-  }
-
-  private createCacheContent(
-    config: CacheConfig,
-    caches: PageCachesInterface,
-  ): CacheContent {
-    return {
-      level: config.level,
-      interval: config.interval,
-      includes: config.includes || null,
-      limit: config.staleLimit,
-      matches: config.matches || null,
-      caches,
-    };
-  }
-
-  async get(context: CacheContext): Promise<CacheResult | null> {
-    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') as string,
-      isStale,
-      isGarbage,
-      hash: cacheHash,
-    };
-  }
-
-  async set(
-    context: CacheContext,
-    html: string,
-    cacheConfig: 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 as CacheContent;
-      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: CacheContext, cacheHash: string) {
-    const cacheKey = this.generateRequestKey(context);
-    const data = this.cache.get(cacheKey);
-    data?.caches.del(cacheHash);
-  }
-}
-
-let manager: CacheManager;
-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/src/libs/render/cache/type.ts

@@ -1,59 +0,0 @@
-import { IncomingHttpHeaders } from 'http';
-import { RenderResult } from '../../../type';
-
-export type { CacheConfig } from '../type';
-
-export type CacheContent = {
-  level: number;
-  includes: {
-    header?: string[];
-    query?: string[];
-  } | null;
-  matches?: {
-    header?: Record<string, Record<string, string>>;
-    query?: Record<string, Record<string, string>>;
-  } | null;
-  interval: number;
-  limit: number | boolean;
-  caches: PageCachesInterface;
-};
-export interface PageCachesInterface {
-  caches: any;
-
-  init: () => void;
-
-  get: (key: string) => Promise<PageCache | null>;
-
-  peek: (key: string) => PageCache | null;
-
-  set: (key: string, cache: PageCache) => Promise<void>;
-
-  del: (key: string) => void;
-
-  keys: () => string[];
-}
-
-export type PageCache = {
-  html: string;
-  expireTime: number;
-  limitTime: number | null;
-  cacheHash: string;
-  size: number;
-};
-
-export type CacheManagerOptions = {
-  max: number;
-};
-
-export interface CacheResult extends RenderResult {
-  isStale: boolean;
-  isGarbage: boolean;
-  hash: string;
-}
-
-export type CacheContext = {
-  entry: string;
-  pathname: string;
-  query: Record<string, string>;
-  headers: IncomingHttpHeaders;
-};

package/src/libs/render/cache/util.ts

@@ -1,97 +0,0 @@
-import { IncomingHttpHeaders } from 'http';
-import url from 'url';
-
-export function namespaceHash(namespace: string, hash: string) {
-  return `${namespace}/${hash}`;
-}
-
-export function fname(lv: number) {
-  return `f${lv}`;
-}
-
-export function connectFactor(...args: string[]) {
-  return args.join('-');
-}
-
-export function valueFactory(obj: url.URLSearchParams | IncomingHttpHeaders) {
-  if (obj instanceof url.URLSearchParams) {
-    return function (key: string) {
-      return obj.get(key);
-    };
-  } else {
-    return function (key: string) {
-      const value = obj[key];
-      if (Array.isArray(value)) {
-        return value.join(',');
-      }
-      return value;
-    };
-  }
-}
-
-export function getTime([s, ns]: [number, number]): number {
-  return Math.floor(s * 1e3 + ns / 1e6);
-}
-
-const RE_START_IN_HEAD = /<head>/;
-export function cacheAddition(html: string, hash: string) {
-  const additionHtml = html.replace(
-    RE_START_IN_HEAD,
-    `<head><meta name="x-moden-spr" content="${hash}">`,
-  );
-  return additionHtml;
-}
-
-type CoalescedInvoke<T> = {
-  isOrigin: boolean;
-  value: T;
-};
-
-type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
-const globalInvokeCache = new Map<string, Promise<CoalescedInvoke<unknown>>>();
-export function withCoalescedInvoke<F extends (...args: any[]) => Promise<any>>(
-  func: F,
-): (
-  key: string,
-  args: Parameters<F>,
-) => Promise<CoalescedInvoke<UnwrapPromise<ReturnType<F>>>> {
-  return async function (key: string, args: Parameters<F>) {
-    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 as UnwrapPromise<ReturnType<F>>,
-      }));
-    }
-
-    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 as UnwrapPromise<ReturnType<F>> };
-      })
-      // 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: () => Promise<any>) {
-  return (sync: boolean) => {
-    if (sync) {
-      return fn();
-    } else {
-      fn();
-      return Promise.resolve();
-    }
-  };
-}

package/src/libs/render/index.ts

@@ -1,78 +0,0 @@
-import path from 'path';
-import { fs } from '@modern-js/utils';
-import mime from 'mime-types';
-import { RenderResult, ServerHookRunner } from '../../type';
-import { ModernRoute } from '../route';
-import { ModernServerContext } from '../context';
-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,
-}: {
-  distDir: string;
-  staticGenerate: boolean;
-}) =>
-  async function render({
-    ctx,
-    route,
-    runner,
-  }: {
-    ctx: ModernServerContext;
-    route: ModernRoute;
-    runner: ServerHookRunner;
-  }): Promise<RenderResult | null> {
-    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,
-            bundle: route.bundle,
-            template: templateHTML,
-            staticGenerate,
-          },
-          runner,
-        );
-        return result;
-      } catch (err) {
-        ctx.error(ERROR_DIGEST.ERENDER, (err as Error).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)) as string,
-    };
-  };

package/src/libs/render/modern/browser-list.ts

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

package/src/libs/render/modern/index.ts

@@ -1,41 +0,0 @@
-import Parser from 'ua-parser-js';
-import compareVersions from 'compare-versions';
-import { ModernServerContext } from '../../context';
-import { NativeModuleNameMap } from './browser-list';
-
-const nativeModules = require('@babel/compat-data/native-modules');
-
-export const supportModern = (context: ModernServerContext) => {
-  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: string) =>
-  filepath.replace(/\.html$/, '-es6.html');

package/src/libs/render/modern/module.d.ts

@@ -1,4 +0,0 @@
-declare module '@babel/compat-data/native-modules' {
-  const nativeModules: { 'es6.module': Record<string, string> };
-  export default nativeModules;
-}