@modern-js/prod-server 1.0.1

package/dist/types/libs/render/ssr.d.ts

@@ -0,0 +1,10 @@
+import { ModernServerContext } from '../context';
+import { RenderResult, ServerHookRunner } from '../../type';
+export declare const render: (ctx: ModernServerContext, renderOptions: {
+  distDir: string;
+  bundle: string;
+  urlPath: string;
+  template: string;
+  entryName: string;
+  staticGenerate: boolean;
+}, runner: ServerHookRunner) => Promise<RenderResult>;

package/dist/types/libs/render/static.d.ts

@@ -0,0 +1,3 @@
+import { RenderResult } from '../../type';
+import { ModernServerContext } from '../context';
+export declare function handleDirectory(ctx: ModernServerContext, entryPath: string, urlPath: string): Promise<RenderResult | null>;

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

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

package/dist/types/libs/route/index.d.ts

@@ -0,0 +1,15 @@
+import { RouteMatcher } from './matcher';
+import { ModernRoute, ModernRouteInterface } from './route';
+export declare class RouteMatchManager {
+  matchers: RouteMatcher[];
+  private specs;
+  constructor();
+  private filter;
+  private best;
+  reset(specs: ModernRouteInterface[]): void;
+  match(pathname: string): RouteMatcher | undefined;
+  matchEntry(entryname: string): RouteMatcher | undefined;
+  getBundles(): (string | undefined)[];
+}
+export type { ModernRouteInterface, ModernRoute };
+export { RouteMatcher };

package/dist/types/libs/route/matcher.d.ts

@@ -0,0 +1,15 @@
+import { MatchFunction } from 'path-to-regexp';
+import { ModernRoute, ModernRouteInterface } from './route';
+export declare class RouteMatcher {
+  spec: ModernRouteInterface;
+  urlPath: string;
+  urlMatcher?: MatchFunction;
+  urlReg?: RegExp;
+  constructor(spec: ModernRouteInterface);
+  generate(url: string): ModernRoute;
+  parseURLParams(pathname: string): Record<string, string>;
+  matchLength(pathname: string): number | null;
+  matchUrlPath(requestUrl: string): boolean;
+  matchEntry(entryName: string): boolean;
+  private setupUrlPath;
+}

package/dist/types/libs/route/route.d.ts

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

package/dist/types/libs/serve-file.d.ts

@@ -0,0 +1,8 @@
+import { NextFunction } from '../type';
+import { ModernServerContext } from './context';
+declare type Rule = {
+  path: string | RegExp;
+  target: string;
+};
+export declare const createStaticFileHandler: (rules: Rule[]) => (context: ModernServerContext, next: NextFunction) => Promise<void>;
+export {};

package/dist/types/server/index.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse, Server as httpServer } from 'http';
+import { ModernServerOptions, ReadyOptions } from '../type';
+import { ModernServer } from './modern-server';
+export declare class Server {
+  options: ModernServerOptions;
+  protected serverImpl: (options: ModernServerOptions) => ModernServer;
+  private server;
+  private app;
+  private runner;
+  constructor(options: ModernServerOptions);
+  getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: (() => void) | undefined) => void;
+  ready(readyOptions?: ReadyOptions): void;
+  init(): Promise<this>;
+  listen(port: number | undefined, listener: any): void;
+  listener(app: httpServer): void;
+  close(): Promise<void>;
+  private createHookRunner;
+  private initAppContext;
+}

package/dist/types/server/modern-server-split.d.ts

@@ -0,0 +1,26 @@
+import { APIServerStartInput } from '@modern-js/server-core';
+import { mergeExtension } from '../utils';
+import { ModernRoute, ModernRouteInterface, RouteMatcher } from '../libs/route';
+import { ApiServerMode } from '../constants';
+import { ModernServerContext } from '../libs/context';
+import { ModernServer } from './modern-server';
+export declare class ModernSSRServer extends ModernServer {
+  protected warmupSSRBundle(): Promise<void>;
+  protected verifyMatch(context: ModernServerContext, matched: RouteMatcher): void;
+  protected prepareAPIHandler(_m: ApiServerMode, _: APIServerStartInput['config']): any;
+  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<import("@modern-js/server-core").Adapter>;
+  protected preServerInit(): Promise<void>;
+}
+export declare class ModernAPIServer extends ModernServer {
+  protected emitRouteHook(_: string, _input: any): Promise<void>;
+  protected warmupSSRBundle(): Promise<void>;
+  protected prepareWebHandler(_: ReturnType<typeof mergeExtension>): any;
+  protected prepareAPIHandler(mode: ApiServerMode, extension: APIServerStartInput['config']): Promise<import("@modern-js/server-core").Adapter>;
+  protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
+  protected preServerInit(): Promise<void>;
+}
+export declare class ModernWebServer extends ModernServer {
+  protected warmupSSRBundle(): Promise<void>;
+  protected handleAPI(context: ModernServerContext): Promise<void>;
+  protected handleWeb(context: ModernServerContext, route: ModernRoute): Promise<any>;
+}

package/dist/types/server/modern-server.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse, Server } from 'http';
+import { Adapter, APIServerStartInput } from '@modern-js/server-core';
+import type { NormalizedConfig } from '@modern-js/core';
+import { ModernServerOptions, NextFunction, ServerHookRunner, Metrics, Logger, ReadyOptions } from '../type';
+import { RouteMatchManager, ModernRouteInterface, ModernRoute, RouteMatcher } from '../libs/route';
+import { mergeExtension } from '../utils';
+import * as reader from '../libs/render/reader';
+import { ModernServerContext } from '../libs/context';
+import { ApiServerMode } from '../constants';
+declare type ModernServerHandler = (context: ModernServerContext, next: NextFunction) => Promise<void> | void;
+declare type ModernServerAsyncHandler = (context: ModernServerContext, next: NextFunction) => Promise<void>;
+export declare class ModernServer {
+  protected pwd: string;
+  protected distDir: string;
+  protected workDir: string;
+  protected router: RouteMatchManager;
+  protected conf: NormalizedConfig;
+  protected handlers: ModernServerAsyncHandler[];
+  protected presetRoutes?: ModernRouteInterface[];
+  protected runner: ServerHookRunner;
+  protected readonly logger: Logger;
+  protected readonly metrics: Metrics;
+  protected reader: typeof reader;
+  protected readonly proxyTarget: ModernServerOptions['proxyTarget'];
+  private staticFileHandler;
+  private routeRenderHandler;
+  private frameWebHandler;
+  private frameAPIHandler;
+  private proxyHandler;
+  private _handler;
+  private readonly staticGenerate;
+  constructor({
+    pwd,
+    config,
+    routes,
+    staticGenerate,
+    logger,
+    metrics,
+    proxyTarget
+  }: ModernServerOptions);
+  getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
+  init(runner: ServerHookRunner): Promise<void>;
+  ready(_: ReadyOptions): void;
+  onListening(_: Server): void;
+  close(): Promise<void>;
+  createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server>;
+  protected readRouteSpec(): ModernRouteInterface[];
+  protected addHandler(handler: ModernServerHandler): void;
+  protected render404(context: ModernServerContext): void;
+  protected prepareFrameHandler(): Promise<void>;
+  protected proxy(): Promise<any>;
+  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<Adapter>;
+  protected prepareAPIHandler(mode: ApiServerMode, extension: APIServerStartInput['config']): Promise<Adapter>;
+  protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
+  protected emitRouteHook(eventName: 'beforeMatch' | 'afterMatch' | 'beforeRender' | 'afterRender', input: {
+    context: ModernServerContext;
+    [propsName: string]: any;
+  }): Promise<any>;
+  protected warmupSSRBundle(): void;
+  protected preServerInit(): Promise<void>;
+  protected handleAPI(context: ModernServerContext): Promise<void>;
+  protected handleWeb(context: ModernServerContext, route: ModernRoute): Promise<import("../type").RenderResult | null>;
+  protected verifyMatch(_c: ModernServerContext, _m: RouteMatcher): void;
+  private routeHandler;
+  private injectMicroFE;
+  private compose;
+  private requestHandler;
+  private onError;
+  private renderErrorPage;
+}
+export {};

package/dist/types/type.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import { serverManager } from '@modern-js/server-core';
+import type { NormalizedConfig } from '@modern-js/core';
+import type { Metrics, Logger, NextFunction } from '@modern-js/types/server';
+import { ModernRouteInterface } from './libs/route';
+declare module 'http' {
+  interface IncomingMessage {
+    logger: Logger;
+    metrics: Metrics;
+  }
+}
+declare module '@modern-js/core' {
+  interface UserConfig {
+    bff?: {
+      proxy: Record<string, any>;
+    };
+  }
+}
+export declare type ModernServerOptions = {
+  pwd: string;
+  config: NormalizedConfig;
+  plugins?: {
+    pluginPath: string;
+  }[];
+  routes?: ModernRouteInterface[];
+  staticGenerate?: boolean;
+  loggerOptions?: Record<string, string>;
+  metricsOptions?: Record<string, string>;
+  logger?: Logger;
+  metrics?: Metrics;
+  apiOnly?: boolean;
+  ssrOnly?: boolean;
+  webOnly?: boolean;
+  proxyTarget?: {
+    ssr?: string;
+    api?: string;
+  };
+  [propName: string]: any;
+};
+export declare type RenderResult = {
+  content: string | Buffer;
+  contentType: string;
+  statusCode?: number;
+  redirect?: boolean;
+};
+export declare type ConfWithBFF = {
+  bff?: {
+    prefix: string;
+  };
+} & NormalizedConfig;
+export declare type Then<T> = T extends PromiseLike<infer U> ? U : T;
+export declare type ServerHookRunner = Then<ReturnType<typeof serverManager.init>>;
+export declare type ReadyOptions = {
+  routes?: ModernRouteInterface[];
+};
+export type { Metrics, Logger, NextFunction };

package/dist/types/utils.d.ts

@@ -0,0 +1,19 @@
+import type { NormalizedConfig } from '@modern-js/core';
+export declare const mergeExtension: (users: any[]) => {
+  middleware: any[];
+};
+export declare const toMessage: (dig: string, e: Error | string) => string;
+export declare const noop: () => void;
+export declare const createErrorDocument: (status: number, text: string) => string;
+export declare type CollectMiddlewaresResult = {
+  web: any[];
+  api: any[];
+};
+export declare const createMiddlewareCollecter: () => {
+  getMiddlewares: () => CollectMiddlewaresResult;
+  addWebMiddleware: (input: any) => void;
+  addAPIMiddleware: (input: any) => void;
+};
+export declare const toPath: (reg: string, params: Record<string, any>) => string;
+export declare const getStaticReg: (output?: NormalizedConfig['output']) => RegExp;
+export declare const prepareFavicons: (favicon: string | undefined, faviconByEntries?: Record<string, string | undefined> | undefined) => string[];

package/jest.config.js

@@ -0,0 +1,9 @@
+const sharedConfig = require('@scripts/jest-config');
+
+/** @type {import('@jest/types').Config.InitialOptions} */
+module.exports = {
+  // eslint-disable-next-line node/no-unsupported-features/es-syntax
+  ...sharedConfig,
+  testEnvironment: 'node',
+  rootDir: __dirname,
+};

package/modern.config.js

@@ -0,0 +1,2 @@
+// https://modernjs.dev/docs/apis/config/overview
+module.exports = {};

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@modern-js/prod-server",
+  "description": "The meta-framework suite designed from scratch for frontend-focused modern web development.",
+  "homepage": "https://modernjs.dev",
+  "bugs": "https://github.com/modern-js-dev/modern.js/issues",
+  "repository": "modern-js-dev/modern.js",
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js"
+  ],
+  "version": "1.0.1",
+  "jsnext:source": "./src/index.ts",
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/js/node/index.js",
+  "module": "./dist/js/treeshaking/index.js",
+  "jsnext:modern": "./dist/js/modern/index.js",
+  "exports": {
+    ".": {
+      "node": {
+        "jsnext:source": "./src/index.ts",
+        "import": "./dist/js/modern/index.js",
+        "require": "./dist/js/node/index.js"
+      },
+      "default": "./dist/js/treeshaking/index.js"
+    }
+  },
+  "dependencies": {
+    "@modern-js/core": "^1.4.4",
+    "@modern-js/utils": "^1.3.3",
+    "@babel/compat-data": "^7.17.0",
+    "@modern-js/server-core": "^1.2.2",
+    "axios": "^0.24.0",
+    "compare-versions": "^3.6.0",
+    "http-proxy-middleware": "^2.0.1",
+    "ignore-styles": "^5.0.1",
+    "mime-types": "^2.1.32",
+    "path-to-regexp": "^6.2.0",
+    "serve-static": "^1.14.1",
+    "lru-cache": "^6.0.0",
+    "ua-parser-js": "^0.7.28",
+    "lodash.clone": "^4.5.0",
+    "cookie": "^0.4.2"
+  },
+  "devDependencies": {
+    "@modern-js/types": "^1.3.4",
+    "@scripts/jest-config": "0.0.0",
+    "@scripts/build": "0.0.0",
+    "del-cli": "^4.0.1",
+    "@types/lru-cache": "^5.1.1",
+    "@types/mime-types": "^2.1.0",
+    "@types/serve-static": "^1.13.10",
+    "@types/ua-parser-js": "^0.7.36",
+    "@types/lodash.clone": "^4",
+    "@types/cookie": "^0.4.1",
+    "typescript": "^4",
+    "@types/jest": "^26.0.9",
+    "@types/node": "^14",
+    "node-mocks-http": "^1.11.0",
+    "jest": "^27",
+    "portfinder": "^1.0.28"
+  },
+  "sideEffects": false,
+  "modernConfig": {
+    "output": {
+      "packageMode": "node-js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "new": "modern new",
+    "build": "modern build",
+    "dev": "modern build --watch",
+    "test": "jest --passWithNoTests"
+  },
+  "readme": "\n<p align=\"center\">\n  <a href=\"https://modernjs.dev\" target=\"blank\"><img src=\"https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png\" width=\"300\" alt=\"Modern.js Logo\" /></a>\n</p>\n<p align=\"center\">\n现代 Web 工程体系\n  <br/>\n  <a href=\"https://modernjs.dev\" target=\"blank\">\n    modernjs.dev\n  </a>\n</p>\n<p align=\"center\">\n  The meta-framework suite designed from scratch for frontend-focused modern web development\n</p>\n\n# Introduction\n\n> The doc site ([modernjs.dev](https://modernjs.dev)) and articles are only available in Chinese for now, we are planning to add English versions soon.\n\n- [Modern.js: Hello, World!](https://zhuanlan.zhihu.com/p/426707646)\n\n## Getting Started\n\n- [Quick Start](https://modernjs.dev/docs/start)\n- [Guides](https://modernjs.dev/docs/guides)\n- [API References](https://modernjs.dev/docs/apis)\n\n## Contributing\n\n- [Contributing Guide](https://github.com/modern-js-dev/modern.js/blob/main/CONTRIBUTING.md)\n"
+}

package/src/constants.ts

@@ -0,0 +1,26 @@
+export const AGGRED_DIR = {
+  mock: 'config/mock',
+  server: 'server',
+  api: 'api',
+  shared: 'shared',
+  lambda: 'lambda',
+};
+
+export enum ApiServerMode {
+  func = 'function',
+  frame = 'framework',
+}
+
+export const ERROR_DIGEST = {
+  INIT: 'Server init error',
+  ENOTF: 'Page could not be found',
+  WARMUP: 'SSR warmup failed',
+  EINTER: 'Internal server error',
+  ERENDER: 'SSR render failed',
+  EMICROINJ: 'Get micro-frontend info failed',
+};
+
+export const ERROR_PAGE_TEXT: Record<number, string> = {
+  404: 'This page could not be found.',
+  500: 'Internal Server Error.',
+};

package/src/index.ts

@@ -0,0 +1,18 @@
+import { ModernServerOptions } from './type';
+import { Server } from './server';
+
+export { Server };
+export { ModernServer } from './server/modern-server';
+export { createProxyHandler } from './libs/proxy';
+export * from './type';
+export * from './constants';
+
+export default (options: ModernServerOptions): Promise<Server> => {
+  if (options == null) {
+    throw new Error('can not start mserver without options');
+  }
+
+  const server = new Server(options);
+
+  return server.init();
+};

package/src/libs/context/context.ts

@@ -0,0 +1,183 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { URL } from 'url';
+import qs from 'querystring';
+import type {
+  ModernServerContext as ModernServerContextInterface,
+  Metrics,
+  Logger,
+} from '@modern-js/types/server';
+import { toMessage } from '../../utils';
+
+export type ContextOptions = {
+  logger?: Logger;
+  metrics?: Metrics;
+};
+
+export class ModernServerContext implements ModernServerContextInterface {
+  /**
+   * http request
+   */
+  public req: IncomingMessage;
+
+  /**
+   * http response
+   */
+  public res: ServerResponse;
+
+  /**
+   * url params
+   */
+  public params: Record<string, string> = {};
+
+  public logger: Logger;
+
+  public metrics?: Metrics;
+
+  public serverData: Record<string, any>;
+
+  constructor(req: IncomingMessage, res: ServerResponse) {
+    this.req = req;
+    this.res = res;
+    this.logger = req.logger;
+    this.metrics = req.metrics;
+    this.serverData = {};
+
+    this.bind();
+  }
+
+  private bind() {
+    const { req, res } = this as any;
+    req.get = (key: string) => this.getReqHeader(key);
+    res.set = (key: string, value: any) => this.res.setHeader(key, value);
+  }
+
+  public setParams(params: Record<string, string>) {
+    this.params = params;
+  }
+
+  public setServerData(key: string, value: any) {
+    this.serverData[key] = value;
+  }
+
+  public getReqHeader(key: string) {
+    const { req } = this;
+    const field = key.toLowerCase();
+    switch (field) {
+      case 'referer':
+      case 'referrer':
+        return req.headers.referrer || req.headers.referer || '';
+      default:
+        return req.headers[field] || '';
+    }
+  }
+
+  /* request property */
+  public get headers() {
+    return this.req.headers;
+  }
+
+  public get method(): string {
+    return this.req.method!;
+  }
+
+  public get url() {
+    return this.req.url || '';
+  }
+
+  public set url(val) {
+    this.req.url = val;
+  }
+
+  public get host() {
+    let host = this.getReqHeader('X-Forwarded-Host');
+    if (!host) {
+      host = this.getReqHeader('Host');
+    }
+    return (host as string).split(/\s*,\s*/, 1)[0] || '';
+  }
+
+  public get protocol() {
+    if ((this.req.socket as any).encrypted) {
+      return 'https';
+    }
+
+    const proto = this.getReqHeader('X-Forwarded-Proto');
+    return proto ? (proto as string).split(/\s*,\s*/, 1)[0] : 'http';
+  }
+
+  public get origin() {
+    return `${this.protocol}://${this.host}`;
+  }
+
+  public get href() {
+    return this.origin + this.url;
+  }
+
+  public get parsedURL() {
+    const url = new URL(this.req.url!, this.origin);
+    return url;
+  }
+
+  public get path() {
+    return this.parsedURL.pathname;
+  }
+
+  public set path(p) {
+    const url = new URL(this.req.url!, this.origin);
+    // this should never happend
+    if (!url || !p) {
+      return;
+    }
+
+    if (url.pathname === p) {
+      return;
+    }
+
+    url.pathname = p;
+
+    this.url = url.toString();
+  }
+
+  public get querystring() {
+    if (!this.req) {
+      return '';
+    }
+    return this.parsedURL.search.replace(/^\?/, '') || '';
+  }
+
+  public get query() {
+    const str = this.querystring;
+    return qs.parse(str);
+  }
+
+  /* response property */
+  public get status() {
+    return this.res.statusCode;
+  }
+
+  public set status(statusCode) {
+    this.res.statusCode = statusCode;
+  }
+
+  /**
+   * 判断链接是否已经关闭
+   */
+  public resHasHandled(): boolean {
+    return this.res.writableEnded;
+  }
+
+  public logInfo() {
+    return {
+      headers: this.headers,
+      href: this.href,
+      url: this.url,
+    };
+  }
+
+  public error(dig: string, err: Error | string = '') {
+    const message = toMessage(dig, err);
+    const reqInfo = this.logInfo();
+
+    this.logger.error(`${reqInfo.url} - ${message}`, reqInfo);
+  }
+}

package/src/libs/context/index.ts

@@ -0,0 +1,7 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { ModernServerContext } from './context';
+
+export const createContext = (req: IncomingMessage, res: ServerResponse) =>
+  new ModernServerContext(req, res);
+
+export { ModernServerContext };