@modern-js/prod-server 1.1.4 → 1.1.5

package/src/libs/render/reader.ts

@@ -1,119 +0,0 @@
-import { Buffer } from 'buffer';
-import { fs } from '@modern-js/utils';
-import LRU from 'lru-cache';
-
-const Byte = 1;
-const KB = 1024 * Byte;
-const MB = 1024 * KB;
-
-type FileCache = {
-  content: Buffer;
-  mtime: Date;
-};
-
-const getContentLength = (cache: FileCache) => cache.content.length;
-
-const createCacheItem = async (filepath: string, mtime: Date) => {
-  const content = await fs.readFile(filepath);
-
-  return {
-    content,
-    mtime,
-  };
-};
-export class LruReader {
-  private readonly cache: LRU<string, FileCache>;
-
-  // private timer?: NodeJS.Timeout;
-
-  constructor() {
-    this.cache = new LRU({
-      max: 256 * MB,
-      length: getContentLength,
-      maxAge: 5 * 60 * 5000, // 60s
-    });
-  }
-
-  public init() {
-    // this.timeTask();
-  }
-
-  public close() {
-    // if (this.timer) {
-    //   clearInterval(this.timer);
-    // }
-  }
-
-  public async read(filepath: string) {
-    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;
-  }
-
-  public 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: string) => {
-  const file = await reader.read(filepath);
-  return file?.content;
-};
-
-export const updateFile = () => {
-  reader.update();
-};
-
-export const init = () => {
-  reader.init();
-};
-
-export const close = () => {
-  reader.close();
-};

package/src/libs/render/ssr.ts

@@ -1,69 +0,0 @@
-import path from 'path';
-import { mime, SERVER_RENDER_FUNCTION_NAME } from '@modern-js/utils';
-import cookie from 'cookie';
-import { ModernServerContext } from '../context';
-import { RenderResult, ServerHookRunner } from '../../type';
-import cache from './cache';
-import { SSRServerContext } from './type';
-import { createLogger, createMetrics } from './measure';
-
-export const render = async (
-  ctx: ModernServerContext,
-  renderOptions: {
-    distDir: string;
-    bundle: string;
-    urlPath: string;
-    template: string;
-    entryName: string;
-    staticGenerate: boolean;
-  },
-  runner: ServerHookRunner,
-): Promise<RenderResult> => {
-  const { urlPath, bundle, distDir, template, entryName, staticGenerate } =
-    renderOptions;
-  const bundleJS = path.join(distDir, bundle);
-
-  const context: SSRServerContext = {
-    request: {
-      baseUrl: urlPath,
-      params: ctx.params,
-      pathname: ctx.path,
-      host: ctx.host,
-      query: ctx.query as Record<string, string>,
-      url: ctx.href,
-      cookieMap: cookie.parse(ctx.headers.cookie || ''),
-      headers: ctx.headers,
-    },
-    redirection: {},
-    template,
-    entryName,
-    distDir,
-    staticGenerate,
-    logger: undefined!,
-    metrics: undefined!,
-  };
-  context.logger = createLogger(context, ctx.logger);
-  context.metrics = createMetrics(context, 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') as string,
-  };
-};

package/src/libs/render/static.ts

@@ -1,52 +0,0 @@
-import path from 'path';
-import { mime } from '@modern-js/utils';
-import { RenderResult } from '../../type';
-import { ModernServerContext } from '../context';
-import { readFile } from './reader';
-
-export async function handleDirectory(
-  ctx: ModernServerContext,
-  entryPath: string,
-  urlPath: string,
-): Promise<RenderResult | null> {
-  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: string, prefix: string): string => {
-  if (str.startsWith(prefix)) {
-    return str.substring(prefix.length);
-  }
-
-  return str;
-};

package/src/libs/render/type.ts

@@ -1,38 +0,0 @@
-import { BaseSSRServerContext } from '@modern-js/types/server';
-
-type MetaKeyMap = {
-  header?: string[];
-  query?: string[];
-};
-type MetaKeyMatch = {
-  header?: MatchMap;
-  query?: MatchMap;
-};
-type MatchMap = Record<string, Record<string, string>>;
-
-export type CacheConfig = {
-  interval: number;
-  staleLimit: number | boolean;
-  level: number;
-  includes?: MetaKeyMap | null;
-  excludes?: MetaKeyMap | null;
-  matches?: MetaKeyMatch | null;
-};
-
-export enum RenderLevel {
-  CLIENT_RENDER,
-  SERVER_PREFETCH,
-  SERVER_RENDER,
-}
-
-export type SSRServerContext = BaseSSRServerContext & {
-  cacheConfig?: CacheConfig;
-  staticGenerate?: boolean;
-};
-
-export type ModernSSRReactComponent = React.ComponentType<any> & {
-  init: (context: SSRServerContext) => Promise<void>;
-  prefetch: (context: SSRServerContext) => Promise<Record<string, any>>;
-};
-
-export type RenderFunction = (context: SSRServerContext) => Promise<string>;

package/src/libs/route/index.ts

@@ -1,76 +0,0 @@
-import { RouteMatcher } from './matcher';
-import { ModernRoute, ModernRouteInterface } from './route';
-
-export class RouteMatchManager {
-  public matchers: RouteMatcher[];
-
-  private specs: ModernRouteInterface[] = [];
-
-  constructor() {
-    this.matchers = [];
-  }
-
-  // get all routes matches pathname
-  private filter(pathname: string) {
-    return this.matchers.reduce((matches, matcher) => {
-      if (matcher.matchUrlPath(pathname)) {
-        matches.push(matcher);
-      }
-      return matches;
-    }, [] as RouteMatcher[]);
-  }
-
-  // get best match from a set of matches
-  private best(pathname: string, matches: RouteMatcher[]) {
-    let best: RouteMatcher | undefined;
-    let matchedLen = 0;
-
-    for (const match of matches) {
-      const len = match.matchLength(pathname);
-
-      if (len === null) {
-        continue;
-      }
-
-      if (len > matchedLen) {
-        best = match;
-        matchedLen = len;
-      }
-    }
-
-    return best;
-  }
-
-  // reset routes matcher
-  public reset(specs: ModernRouteInterface[]) {
-    this.specs = specs;
-    const matchers = specs.reduce((ms, spec) => {
-      ms.push(new RouteMatcher(spec));
-      return ms;
-    }, [] as RouteMatcher[]);
-
-    this.matchers = matchers;
-  }
-
-  // get best match from all matcher in manager
-  public match(pathname: string) {
-    const matches = this.filter(pathname);
-    const best = this.best(pathname, matches);
-    return best;
-  }
-
-  public matchEntry(entryname: string) {
-    return this.matchers.find(matcher => matcher.matchEntry(entryname));
-  }
-
-  public getBundles() {
-    const bundles = this.specs
-      .filter(route => route.isSSR)
-      .map(route => route.bundle);
-
-    return bundles;
-  }
-}
-
-export type { ModernRouteInterface, ModernRoute };
-export { RouteMatcher };

package/src/libs/route/matcher.ts

@@ -1,108 +0,0 @@
-import { removeTailSlash } from '@modern-js/utils';
-import {
-  MatchFunction,
-  MatchResult,
-  match,
-  pathToRegexp,
-} from 'path-to-regexp';
-import { toPath } from '../../utils';
-import { ModernRoute, ModernRouteInterface } from './route';
-
-// eslint-disable-next-line no-useless-escape
-const regCharsDetector = /[^a-zA-Z\-_0-9\/\.]/;
-export class RouteMatcher {
-  public spec: ModernRouteInterface;
-
-  public urlPath: string = '';
-
-  public urlMatcher?: MatchFunction;
-
-  public urlReg?: RegExp;
-
-  constructor(spec: ModernRouteInterface) {
-    this.spec = spec;
-    this.setupUrlPath();
-  }
-
-  // generate modern route object
-  public generate(url: string) {
-    const route = new ModernRoute(this.spec);
-
-    if (this.urlPath) {
-      const params = this.parseURLParams(url);
-      route.urlPath = toPath(route.urlPath, params);
-      route.params = params;
-    }
-
-    return route;
-  }
-
-  public parseURLParams(pathname: string) {
-    if (!this.urlMatcher) {
-      return {};
-    } else {
-      const matchResult = this.urlMatcher(pathname);
-
-      return (matchResult as MatchResult<Record<string, string>>).params;
-    }
-  }
-
-  // get match url length
-  public matchLength(pathname: string): number | null {
-    if (!this.urlReg) {
-      return this.urlPath.length;
-    } else {
-      const result = this.urlReg.exec(pathname);
-      return result?.[0]?.length || null;
-    }
-  }
-
-  // if match url path
-  public matchUrlPath(requestUrl: string): boolean {
-    const urlWithoutSlash =
-      requestUrl.endsWith('/') && requestUrl !== '/'
-        ? requestUrl.slice(0, -1)
-        : requestUrl;
-
-    if (this.urlMatcher) {
-      return Boolean(this.urlMatcher(urlWithoutSlash));
-    } else {
-      if (urlWithoutSlash.startsWith(this.urlPath)) {
-        // avoid /abcd match /a
-        if (
-          this.urlPath !== '/' &&
-          urlWithoutSlash.length > this.urlPath.length &&
-          !urlWithoutSlash.startsWith(`${this.urlPath}/`)
-        ) {
-          return false;
-        }
-
-        return true;
-      }
-
-      return false;
-    }
-  }
-
-  public matchEntry(entryName: string): boolean {
-    return this.spec.entryName === entryName;
-  }
-
-  // compiler urlPath to regexp if necessary
-  private setupUrlPath() {
-    const { urlPath } = this.spec;
-    this.urlPath = urlPath === '/' ? urlPath : removeTailSlash(urlPath);
-
-    const useReg = regCharsDetector.test(urlPath);
-    if (useReg) {
-      this.urlMatcher = match(urlPath, {
-        end: false,
-        decode: decodeURIComponent,
-      });
-
-      this.urlReg = pathToRegexp(urlPath, [], {
-        end: false,
-      });
-    }
-  }
-}

package/src/libs/route/route.ts

@@ -1,34 +0,0 @@
-import { ServerRoute as ModernRouteInterface } from '@modern-js/types';
-
-export type { ModernRouteInterface };
-
-export class ModernRoute implements ModernRouteInterface {
-  public entryName: string;
-
-  public urlPath: string;
-
-  public entryPath: string;
-
-  public bundle: string;
-
-  public isApi: boolean;
-
-  public isSSR: boolean;
-
-  public isSPA: boolean;
-
-  public enableModernMode?: boolean;
-
-  public params: Record<string, any> = {};
-
-  constructor(routeSpec: ModernRouteInterface) {
-    this.entryName = routeSpec.entryName || '';
-    this.urlPath = routeSpec.urlPath;
-    this.entryPath = routeSpec.entryPath || '';
-    this.isSSR = routeSpec.isSSR || false;
-    this.isSPA = routeSpec.isSPA || false;
-    this.isApi = routeSpec.isApi || false;
-    this.bundle = routeSpec.bundle || '';
-    this.enableModernMode = routeSpec.enableModernMode ?? false;
-  }
-}

package/src/libs/serve-file.ts

@@ -1,34 +0,0 @@
-// Todo 看看是不是能 fork 一份，即使命中也返回
-import serve from 'serve-static';
-import { isString, isRegExp } from '@modern-js/utils';
-import { NextFunction } from '../type';
-import { ModernServerContext } from './context';
-
-type Rule = {
-  path: string | RegExp;
-  target: string;
-};
-
-export const createStaticFileHandler =
-  (rules: Rule[]) =>
-  // eslint-disable-next-line consistent-return
-  async (context: ModernServerContext, next: NextFunction) => {
-    const { url: requestUrl, req, res } = context;
-
-    const hitRule = rules.find(item => {
-      if (isString(item.path) && requestUrl.startsWith(item.path)) {
-        return true;
-      } else if (isRegExp(item.path) && item.path.test(requestUrl)) {
-        return true;
-      }
-      return false;
-    });
-
-    if (hitRule) {
-      serve(hitRule.target)(req, res, () => {
-        next();
-      });
-    } else {
-      return next();
-    }
-  };