@modern-js/prod-server 2.42.2 → 2.44.0

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

@@ -1,212 +0,0 @@
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-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 {
-  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_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;
-    }
-    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);
-    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
-    };
-  }
-  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
-      });
-      this.cache.set(cacheKey, next);
-      return true;
-    };
-    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);
-  }
-  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() {
-  if (manager) {
-    return manager;
-  }
-  manager = new CacheManager({
-    max: 0
-  });
-  return manager;
-}
-function destroyCache() {
-  manager = null;
-}
-export {
-  createCache,
-  destroyCache
-};

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

@@ -1,80 +0,0 @@
-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 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) {
-  return (sync) => {
-    if (sync) {
-      return fn();
-    } else {
-      fn();
-      return Promise.resolve();
-    }
-  };
-}
-export {
-  cacheAddition,
-  connectFactor,
-  fname,
-  getTime,
-  maybeSync,
-  namespaceHash,
-  valueFactory,
-  withCoalescedInvoke
-};

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

@@ -1,93 +0,0 @@
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import { fs as extraFS } 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 (content, mtime) => {
-  return {
-    content,
-    mtime
-  };
-};
-class LruReader {
-  init(fs) {
-    this.fs = fs || extraFS;
-  }
-  close() {
-  }
-  async read(filepath) {
-    const { fs } = this;
-    if (this.cache.has(filepath)) {
-      const { content: content2 } = this.cache.get(filepath);
-      return {
-        content: content2
-      };
-    }
-    if (!fs.existsSync(filepath)) {
-      return null;
-    }
-    const stat = fs.statSync(filepath);
-    if (stat.isDirectory()) {
-      return null;
-    }
-    if (stat.size > 20 * MB) {
-      return null;
-    }
-    const content = await fs.promises.readFile(filepath);
-    const item = await createCacheItem(content, stat.mtime);
-    this.cache.set(filepath, item);
-    return item;
-  }
-  update() {
-    const { cache, fs } = 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);
-      }
-    }
-  }
-  constructor() {
-    _define_property(this, "cache", void 0);
-    _define_property(this, "fs", void 0);
-    this.cache = new LRU({
-      max: 256 * MB,
-      length: getContentLength,
-      maxAge: 5 * 60 * 5e3
-    });
-    this.fs = extraFS;
-  }
-}
-const reader = new LruReader();
-const readFile = async (filepath) => {
-  const file = await reader.read(filepath);
-  return file === null || file === void 0 ? void 0 : file.content;
-};
-const updateFile = () => {
-  reader.update();
-};
-const init = (fs) => {
-  reader.init(fs);
-};
-const close = () => {
-  reader.close();
-};
-export {
-  LruReader,
-  close,
-  init,
-  readFile,
-  updateFile
-};

package/dist/types/libs/render/cache/__tests__/cache.fun.test.d.ts

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

package/dist/types/libs/render/cache/__tests__/cache.test.d.ts

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

package/dist/types/libs/render/cache/__tests__/cacheable.d.ts

@@ -1,62 +0,0 @@
-export declare const cacheabelAry: ({
-    requestOpt: {
-        url: string;
-        query?: undefined;
-        headers?: undefined;
-    };
-    cacheConfig: {
-        level?: undefined;
-        includes?: undefined;
-    };
-    content: string;
-} | {
-    requestOpt: {
-        url: string;
-        query: {
-            name: string;
-        };
-        headers?: undefined;
-    };
-    cacheConfig: {
-        level: number;
-        includes: {
-            query: string[];
-            header?: undefined;
-        };
-    };
-    content: string;
-} | {
-    requestOpt: {
-        url: string;
-        headers: {
-            age: string;
-        };
-        query?: undefined;
-    };
-    cacheConfig: {
-        level: number;
-        includes: {
-            header: string[];
-            query?: undefined;
-        };
-    };
-    content: string;
-} | {
-    requestOpt: {
-        url: string;
-        query: {
-            name: string;
-        };
-        headers: {
-            age: string;
-        };
-    };
-    cacheConfig: {
-        level: number;
-        includes: {
-            query: string[];
-            header: string[];
-        };
-    };
-    content: string;
-})[];

package/dist/types/libs/render/cache/__tests__/error-configuration.d.ts

@@ -1,28 +0,0 @@
-export declare const errorConfiguration: ({
-    level: number;
-    includes?: undefined;
-} | {
-    level: number;
-    includes: {
-        query?: undefined;
-        header?: undefined;
-    };
-} | {
-    level: number;
-    includes: {
-        query: never[];
-        header?: undefined;
-    };
-} | {
-    level: number;
-    includes: {
-        header: never[];
-        query?: undefined;
-    };
-} | {
-    level: number;
-    includes: {
-        query: never[];
-        header: never[];
-    };
-})[];

package/dist/types/libs/render/cache/__tests__/matched-cache.d.ts

@@ -1,124 +0,0 @@
-export declare const matchedCacheableAry: (({
-    requestOpt: {
-        url: string;
-        headers: {};
-        query: {
-            name: string;
-        };
-    };
-    cacheConfig: {
-        level: number;
-        includes: {
-            query: string[];
-        };
-        matches: {
-            query: {
-                name: {
-                    weixin: string;
-                };
-            };
-        };
-    };
-    content: string;
-    url?: undefined;
-    headers?: undefined;
-    query?: undefined;
-} | {
-    url: string;
-    headers: {};
-    query: {
-        name: string;
-    };
-    requestOpt?: undefined;
-    cacheConfig?: undefined;
-    content?: undefined;
-})[] | ({
-    requestOpt: {
-        url: string;
-        query: {};
-        headers: {
-            age: string;
-        };
-    };
-    cacheConfig: {
-        level: number;
-        includes: {
-            header: string[];
-        };
-        matches: {
-            header: {
-                age: {
-                    one: string;
-                };
-            };
-        };
-    };
-    content: string;
-    url?: undefined;
-    query?: undefined;
-    headers?: undefined;
-} | {
-    url: string;
-    query: {};
-    headers: {
-        age: string;
-    };
-    requestOpt?: undefined;
-    cacheConfig?: undefined;
-    content?: undefined;
-})[] | ({
-    requestOpt: {
-        url: string;
-        headers: {
-            age: string;
-        };
-        query: {
-            name: string;
-        };
-    };
-    cacheConfig: {
-        level: number;
-        includes: {
-            query: string[];
-            header: string[];
-        };
-        matches: {
-            query: {
-                name: {
-                    weixin: string;
-                };
-            };
-            header: {
-                age: {
-                    one: string;
-                };
-            };
-        };
-    };
-    content: string;
-    url?: undefined;
-    query?: undefined;
-    headers?: undefined;
-} | {
-    url: string;
-    query: {
-        name: string;
-    };
-    headers: {
-        age: string;
-    };
-    requestOpt?: undefined;
-    cacheConfig?: undefined;
-    content?: undefined;
-} | {
-    url: string;
-    query: {
-        name: string;
-    };
-    headers: {
-        age?: undefined;
-    };
-    requestOpt?: undefined;
-    cacheConfig?: undefined;
-    content?: undefined;
-})[])[];

package/dist/types/libs/render/cache/index.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="node" />
-import { Readable } from 'stream';
-import type { ModernServerContext } from '@modern-js/types';
-import { RenderFunction, SSRServerContext } from '../type';
-declare const _default: (renderFn: RenderFunction, ctx: ModernServerContext) => (context: SSRServerContext) => Promise<string | Readable>;
-export default _default;

package/dist/types/libs/render/cache/page-caches/index.d.ts

@@ -1,2 +0,0 @@
-import { PageCachesInterface } from '../type';
-export declare function createPageCaches(max: number): Promise<PageCachesInterface>;

package/dist/types/libs/render/cache/page-caches/lru.d.ts

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

package/dist/types/libs/render/cache/spr.d.ts

@@ -1,22 +0,0 @@
-import LRUCache from 'lru-cache';
-import { CacheContent, CacheManagerOptions, CacheResult, CacheContext, CacheConfig } from './type';
-declare class CacheManager {
-    cache: LRUCache<string, CacheContent>;
-    cacheOptions: CacheManagerOptions;
-    constructor(cacheOptions: CacheManagerOptions);
-    private md5;
-    private generateRequestKey;
-    private replaceValue;
-    private factor;
-    private queryFactor;
-    private headerFactor;
-    private readonly find;
-    private best;
-    private createCacheContent;
-    get(context: CacheContext): Promise<CacheResult | null>;
-    set(context: CacheContext, html: string, cacheConfig: CacheConfig, sync?: boolean): Promise<any>;
-    del(context: CacheContext, cacheHash: string): Promise<void>;
-}
-export declare function createCache(): CacheManager;
-export declare function destroyCache(): void;
-export {};

package/dist/types/libs/render/cache/type.d.ts

@@ -1,48 +0,0 @@
-/// <reference types="node" />
-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;
-};