@modern-js/prod-server 1.0.1

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

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

package/src/libs/render/reader.ts

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,67 @@
+import path from 'path';
+import { SERVER_RENDER_FUNCTION_NAME } from '@modern-js/utils';
+import mime from 'mime-types';
+import cookie from 'cookie';
+import { ModernServerContext } from '../context';
+import { RenderResult, ServerHookRunner } from '../../type';
+import cache from './cache';
+import { SSRServerContext } from './type';
+
+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: 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') as string,
+  };
+};

package/src/libs/render/static.ts

@@ -0,0 +1,52 @@
+import path from 'path';
+import mime from 'mime-types';
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,34 @@
+// 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();
+    }
+  };

package/src/server/index.ts

@@ -0,0 +1,147 @@
+import { IncomingMessage, ServerResponse, Server as httpServer } from 'http';
+import path from 'path';
+import {
+  serverManager,
+  AppContext,
+  ConfigContext,
+} from '@modern-js/server-core';
+import { compatRequire, logger as defaultLogger } from '@modern-js/utils';
+import {
+  initAppContext,
+  initAppDir,
+  loadUserConfig,
+  UserConfig,
+} from '@modern-js/core';
+import { ModernServerOptions, ServerHookRunner, ReadyOptions } from '../type';
+import { metrics as defaultMetrics } from '../libs/metrics';
+import { ModernServer } from './modern-server';
+import {
+  ModernAPIServer,
+  ModernSSRServer,
+  ModernWebServer,
+} from './modern-server-split';
+
+const createProdServer = (options: ModernServerOptions): ModernServer => {
+  if (options.apiOnly) {
+    return new ModernAPIServer(options);
+  } else if (options.ssrOnly) {
+    return new ModernSSRServer(options);
+  } else if (options.webOnly) {
+    return new ModernWebServer(options);
+  } else {
+    return new ModernServer(options);
+  }
+};
+
+export class Server {
+  public options: ModernServerOptions;
+
+  protected serverImpl: (options: ModernServerOptions) => ModernServer =
+    createProdServer;
+
+  private server!: ModernServer;
+
+  private app!: httpServer;
+
+  private runner!: ServerHookRunner;
+
+  constructor(options: ModernServerOptions) {
+    this.options = options;
+  }
+
+  public getRequestHandler() {
+    return (req: IncomingMessage, res: ServerResponse, next?: () => void) => {
+      const requestHandler = this.server.getRequestHandler();
+      return requestHandler(req, res, next);
+    };
+  }
+
+  public ready(readyOptions: ReadyOptions = {}) {
+    this.server.ready(readyOptions);
+  }
+
+  public async init() {
+    const { options } = this;
+
+    options.logger = options.logger || defaultLogger;
+    options.metrics = options.metrics || defaultMetrics;
+
+    // initialize server
+    this.server = this.serverImpl(options);
+
+    // create http-server
+    this.app = await this.server.createHTTPServer(this.getRequestHandler());
+
+    this.runner = await this.createHookRunner();
+
+    // runner can only be used after server init
+    await this.server.init(this.runner);
+
+    return this;
+  }
+
+  public listen(port = 8080, listener: any) {
+    this.app.listen(process.env.PORT || port, () => {
+      if (listener) {
+        listener();
+      }
+
+      this.listener(this.app);
+    });
+  }
+
+  public listener(app: httpServer) {
+    this.server.onListening(app);
+  }
+
+  public async close() {
+    await this.server.close();
+    await new Promise<void>(resolve =>
+      this.app.close(() => {
+        resolve();
+      }),
+    );
+  }
+
+  private async createHookRunner() {
+    const { options } = this;
+
+    serverManager.clear();
+
+    options.plugins?.forEach(p => {
+      serverManager.usePlugin(compatRequire(p.pluginPath));
+    });
+
+    const appContext = await this.initAppContext();
+    serverManager.run(() => {
+      ConfigContext.set(this.options.config as UserConfig);
+      AppContext.set({
+        ...appContext,
+        distDirectory: path.join(
+          options.pwd,
+          options.config.output?.path || 'dist',
+        ),
+      });
+    });
+
+    return serverManager.init({});
+  }
+
+  private async initAppContext() {
+    const appDirectory = await initAppDir();
+
+    const loaded = await loadUserConfig(appDirectory);
+
+    const plugins = this.options.plugins?.map(p => ({
+      server: p,
+      cli: undefined,
+    }));
+
+    const appContext = initAppContext(
+      appDirectory,
+      plugins || [],
+      loaded.filePath,
+    );
+    return appContext;
+  }
+}