@modern-js/server 1.1.3 → 1.1.5-beta.1

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

@@ -1,16 +1,26 @@
 import { APIServerStartInput } from '@modern-js/server-plugin';
 import { ModernServer } from './modern-server';
 import { mergeExtension } from "../utils.d";
-import { ModernRouteInterface } from "../libs/route";
+import { ModernRoute, ModernRouteInterface, RouteMatcher } from "../libs/route";
 import { ApiServerMode } from "../constants.d";
-export declare class WebModernServer extends ModernServer {
-  protected prepareAPIHandler(_m: ApiServerMode, _: ReturnType<typeof mergeExtension>): any;
+import { ModernServerContext } from "../libs/context";
+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-plugin").Adapter>;
-  protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
+  protected preServerInit(): Promise<void>;
 }
-export declare class APIModernServer extends ModernServer {
+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-plugin").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

@@ -2,9 +2,9 @@
 import { IncomingMessage, ServerResponse, Server } from 'http';
 import { Adapter, APIServerStartInput } from '@modern-js/server-plugin';
 import type { NormalizedConfig } from '@modern-js/core';
-import { ModernServerOptions, NextFunction, ServerHookRunner, Measure, Logger, ReadyOptions } from '../type';
-import { RouteMatchManager, ModernRouteInterface } from '../libs/route';
-import { mergeExtension } from '../utils';
+import { ModernServerOptions, NextFunction, ServerHookRunner, Metrics, Logger, ReadyOptions } from "../type.d";
+import { RouteMatchManager, ModernRouteInterface, ModernRoute, RouteMatcher } from "../libs/route";
+import { mergeExtension } from "../utils.d";
 import { ModernServerContext } from "../libs/context";
 import { ApiServerMode } from "../constants.d";
 declare type ModernServerHandler = (context: ModernServerContext, next: NextFunction) => Promise<void> | void;
@@ -19,7 +19,8 @@ export declare class ModernServer {
   protected presetRoutes?: ModernRouteInterface[];
   protected runner: ServerHookRunner;
   protected readonly logger: Logger;
-  protected readonly measure: Measure;
+  protected readonly metrics: Metrics;
+  protected readonly proxyTarget: ModernServerOptions['proxyTarget'];
   private readonly isDev;
   private staticFileHandler;
   private routeRenderHandler;
@@ -35,7 +36,8 @@ export declare class ModernServer {
     routes,
     staticGenerate,
     logger,
-    measure
+    metrics,
+    proxyTarget
   }: ModernServerOptions);
   getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
   init(runner: ServerHookRunner): Promise<void>;
@@ -43,21 +45,26 @@ export declare class ModernServer {
   onListening(_: Server): void;
   close(): void;
   createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server>;
-  protected warmupSSRBundle(): void;
   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: any): Promise<any>;
+  protected warmupSSRBundle(): void;
   protected preServerInit(): Promise<void>;
-  private prepareFavicons;
+  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;
+  private prepareFavicons;
 }
 export {};

package/dist/types/type.d.ts

@@ -2,7 +2,7 @@
 import type Webpack from 'webpack';
 import { serverManager } from '@modern-js/server-plugin';
 import type { NormalizedConfig } from '@modern-js/core';
-import type { Measure, Logger, NextFunction } from '@modern-js/types/server';
+import type { Metrics, Logger, NextFunction } from '@modern-js/types/server';
 import { ModernRouteInterface } from './libs/route';
 declare module '@modern-js/core' {
   interface UserConfig {
@@ -23,6 +23,7 @@ export declare type DevServerOptions = {
   dev: {
     writeToDisk: boolean | ((filename: string) => boolean);
   };
+  watch: boolean;
   hot: boolean | string;
   liveReload: boolean;
   https?: boolean | {
@@ -35,17 +36,22 @@ export declare type ModernServerOptions = {
   pwd: string;
   config: NormalizedConfig;
   plugins?: any[];
-  dev?: boolean | DevServerOptions;
+  dev?: boolean | Partial<DevServerOptions>;
   compiler?: Webpack.MultiCompiler | Webpack.Compiler;
   routes?: ModernRouteInterface[];
   staticGenerate?: boolean;
   customServer?: boolean;
   loggerOptions?: Record<string, string>;
-  measureOptions?: Record<string, string>;
+  metricsOptions?: Record<string, string>;
   logger?: Logger;
-  measure?: Measure;
+  metrics?: Metrics;
   apiOnly?: boolean;
+  ssrOnly?: boolean;
   webOnly?: boolean;
+  proxyTarget?: {
+    ssr?: string;
+    api?: string;
+  };
 };
 export declare type RenderResult = {
   content: string | Buffer;
@@ -63,4 +69,4 @@ export declare type ServerHookRunner = Then<ReturnType<typeof serverManager.init
 export declare type ReadyOptions = {
   routes?: ModernRouteInterface[];
 };
-export type { Measure, Logger, NextFunction };
+export type { Metrics, Logger, NextFunction };

package/dist/types/utils.d.ts

@@ -3,4 +3,5 @@ export declare const mergeExtension: (users: 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 const createErrorDocument: (status: number, text: string) => string;
+export declare function applyMixins(derivedCtor: any, constructors: any[]): void;

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.1.3",
+  "version": "1.1.5-beta.1",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -33,12 +33,12 @@
     "@babel/preset-typescript": "^7.15.0",
     "@babel/register": "^7.15.3",
     "@babel/runtime": "^7",
-    "@modern-js/core": "^1.1.3",
+    "@modern-js/core": "^1.1.4",
     "@modern-js/hmr-client": "^1.1.1",
     "@modern-js/server-plugin": "^1.1.2",
     "@modern-js/server-utils": "^1.1.2",
     "@modern-js/bff-utils": "^1.1.1",
-    "@modern-js/utils": "^1.1.3",
+    "@modern-js/utils": "^1.1.4",
     "axios": "^0.21.4",
     "babel-plugin-module-resolver": "^4.1.0",
     "chokidar": "^3.5.2",
@@ -61,9 +61,9 @@
     "ws": "^8.2.0"
   },
   "devDependencies": {
-    "@modern-js/module-tools": "^1.1.1",
+    "@modern-js/module-tools": "^1.1.2",
     "@modern-js/plugin-testing": "^1.1.1",
-    "@modern-js/types": "^1.1.2",
+    "@modern-js/types": "^1.1.3",
     "@types/jest": "^26",
     "@types/lru-cache": "^5.1.1",
     "@types/mime-types": "^2.1.0",

package/src/libs/context/context.ts

@@ -3,7 +3,7 @@ import { URL } from 'url';
 import qs from 'querystring';
 import type {
   ModernServerContext as ModernServerContextInterface,
-  Measure,
+  Metrics,
   Logger,
 } from '@modern-js/types/server';
 import { toMessage } from '../../utils';
@@ -26,17 +26,25 @@ export class ModernServerContext implements ModernServerContextInterface {
 
   public logger: Logger;
 
-  public measure?: Measure;
+  public metrics?: Metrics;
 
   constructor(
     req: IncomingMessage,
     res: ServerResponse,
-    { logger, measure }: { logger: Logger; measure: Measure },
+    { logger, metrics }: { logger: Logger; metrics: Metrics },
   ) {
     this.req = req;
     this.res = res;
     this.logger = logger;
-    this.measure = measure;
+    this.metrics = metrics;
+
+    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>) {
@@ -60,10 +68,6 @@ export class ModernServerContext implements ModernServerContextInterface {
     return this.req.headers;
   }
 
-  public set headers(val) {
-    this.req.headers = val;
-  }
-
   public get method(): string {
     return this.req.method!;
   }

package/src/libs/context/index.ts

@@ -1,11 +1,11 @@
 import { IncomingMessage, ServerResponse } from 'http';
-import { Measure, Logger } from '../../type';
+import { Metrics, Logger } from '../../type';
 import { ModernServerContext } from './context';
 
 export const createContext = (
   req: IncomingMessage,
   res: ServerResponse,
-  { logger, measure }: { logger: Logger; measure: Measure },
-) => new ModernServerContext(req, res, { logger, measure });
+  { logger, metrics }: { logger: Logger; metrics: Metrics },
+) => new ModernServerContext(req, res, { logger, metrics });
 
 export { ModernServerContext };

package/src/libs/{measure.ts → metrics.ts}

@@ -1,6 +1,6 @@
-import { Measure } from '@/type';
+import { Metrics } from '@/type';
 
-const measure: Measure = {
+const metrics: Metrics = {
   gauges() {
     // no impl
   },
@@ -12,4 +12,4 @@ const measure: Measure = {
   },
 };
 
-export { measure };
+export { metrics };

package/src/libs/render/index.ts

@@ -9,6 +9,7 @@ import { readFile } from './reader';
 import * as ssr from './ssr';
 import { supportModern, getModernEntry } from './modern';
 import { ERROR_DIGEST } from '@/constants';
+import { ServerHookRunner } from '@/type';
 
 export const createRenderHandler = ({
   distDir,
@@ -17,10 +18,15 @@ export const createRenderHandler = ({
   distDir: string;
   staticGenerate: boolean;
 }) =>
-  async function render(
-    ctx: ModernServerContext,
-    route: ModernRoute,
-  ): Promise<RenderResult | null> {
+  async function render({
+    ctx,
+    route,
+    runner,
+  }: {
+    ctx: ModernServerContext;
+    route: ModernRoute;
+    runner: ServerHookRunner;
+  }): Promise<RenderResult | null> {
     if (ctx.resHasHandled()) {
       return null;
     }
@@ -43,13 +49,17 @@ export const createRenderHandler = ({
     // handles ssr first
     if (route.isSSR) {
       try {
-        const result = await ssr.render(ctx, {
-          distDir,
-          entryName: route.entryName,
-          bundle: route.bundle,
-          template: templateHTML,
-          staticGenerate,
-        });
+        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);

package/src/libs/render/ssr.ts

@@ -5,6 +5,7 @@ import { ModernServerContext } from '../context';
 import { RenderResult } from '../../type';
 import cache from './cache';
 import { SSRServerContext } from './type';
+import { ServerHookRunner } from '@/type';
 
 export const render = async (
   ctx: ModernServerContext,
@@ -15,6 +16,7 @@ export const render = async (
     entryName: string;
     staticGenerate: boolean;
   },
+  runner: ServerHookRunner,
 ): Promise<RenderResult> => {
   const { bundle, distDir, template, entryName, staticGenerate } =
     renderOptions;
@@ -34,9 +36,11 @@ export const render = async (
     distDir,
     staticGenerate,
     logger: ctx.logger,
-    measure: ctx.measure,
+    metrics: ctx.metrics,
   };
 
+  runner.extendSSRContext(context);
+
   const serverRender = require(bundleJS)[SERVER_RENDER_FUNCTION_NAME];
 
   const html = await cache(serverRender, ctx)(context);

package/src/libs/render/type.ts

@@ -1,5 +1,6 @@
 import { IncomingHttpHeaders } from 'http';
-import { Measure, Logger } from '../../type';
+import { BaseSSRServerContext } from '@modern-js/types/server';
+import { Metrics, Logger } from '../../type';
 
 type MetaKeyMap = {
   header?: string[];
@@ -26,21 +27,7 @@ export enum RenderLevel {
   SERVER_RENDER,
 }
 
-export type SSRServerContext = {
-  request: {
-    params: Record<string, string>;
-    pathname: string;
-    query: Record<string, string>;
-    headers: IncomingHttpHeaders;
-    cookie?: string;
-  };
-  redirection: { url?: string; status?: number };
-  distDir: string;
-  template: string;
-  entryName: string;
-  logger: Logger;
-  measure?: Measure;
-  loadableManifest?: string;
+export type SSRServerContext = BaseSSRServerContext & {
   cacheConfig?: CacheConfig;
   staticGenerate?: boolean;
 };

package/src/libs/route/route.ts

@@ -1,22 +1,6 @@
-export interface ModernRouteInterface {
-  // modern js web entry name
-  entryName: string;
-  // the url path for request match
-  urlPath: string;
-  // the default resource file to response to route
-  entryPath?: string;
-  // if route is spa page
-  isSPA?: boolean;
-  // if route is ssr page
-  isSSR?: boolean;
-  // if route is api service
-  isApi?: boolean;
-  // ssr js bundle for ssr page
-  bundle?: string;
-  // if route has modern product
-  enableModernMode?: boolean;
-  // specialHeader?: SpecialHeader[];
-}
+import { ServerRoute as ModernRouteInterface } from '@modern-js/types';
+
+export type { ModernRouteInterface };
 
 export class ModernRoute implements ModernRouteInterface {
   public entryName: string;
@@ -36,7 +20,7 @@ export class ModernRoute implements ModernRouteInterface {
   public enableModernMode?: boolean;
 
   constructor(routeSpec: ModernRouteInterface) {
-    this.entryName = routeSpec.entryName;
+    this.entryName = routeSpec.entryName || '';
     this.urlPath = routeSpec.urlPath;
     this.entryPath = routeSpec.entryPath || '';
     this.isSSR = routeSpec.isSSR || false;

package/src/server/dev-server/dev-server-split.ts

@@ -4,7 +4,7 @@ import { mergeExtension } from '@/utils';
 import { ModernRouteInterface } from '@/libs/route';
 import { ApiServerMode } from '@/constants';
 
-export class WebModernDevServer extends ModernDevServer {
+export class ModernSSRDevServer extends ModernDevServer {
   protected prepareAPIHandler(
     _m: ApiServerMode,
     _: APIServerStartInput['config'],
@@ -23,14 +23,10 @@ export class WebModernDevServer extends ModernDevServer {
   }
 }
 
-export class APIModernDevServer extends ModernDevServer {
-  protected prepareWebHandler(_: ReturnType<typeof mergeExtension>) {
-    return null as any;
-  }
-
+export class ModernAPIDevServer extends ModernDevServer {
   protected async prepareAPIHandler(
     mode: ApiServerMode,
-    extension: ReturnType<typeof mergeExtension>,
+    extension: APIServerStartInput['config'],
   ) {
     return super.prepareAPIHandler(mode, extension);
   }

package/src/server/dev-server/dev-server.ts

@@ -13,9 +13,7 @@ import {
   SHARED_DIR,
 } from '@modern-js/utils';
 import type { MultiCompiler, Compiler } from 'webpack';
-import webpackDevMiddleware, {
-  WebpackDevMiddleware,
-} from 'webpack-dev-middleware';
+import webpackDevMiddleware from 'webpack-dev-middleware';
 import { ModernServer } from '../modern-server';
 import { createMockHandler } from '@/dev-tools/mock';
 import { createProxyHandler, ProxyOptions } from '@/libs/proxy';
@@ -45,9 +43,11 @@ const DEFAULT_DEV_OPTIONS: DevServerOptions = {
   },
   https: false,
   dev: { writeToDisk: true },
+  watch: true,
   hot: true,
   liveReload: true,
 };
+
 export class ModernDevServer extends ModernServer {
   private devProxyHandler: ReturnType<typeof createProxyHandler> = null;
 
@@ -61,12 +61,10 @@ export class ModernDevServer extends ModernServer {
 
   private watcher!: Watcher;
 
-  private devMiddleware!: WebpackDevMiddleware &
-    ((
-      req: http.IncomingMessage,
-      res: http.ServerResponse,
-      next: NextFunction,
-    ) => void);
+  private devMiddleware!: webpackDevMiddleware.API<
+    http.IncomingMessage,
+    http.ServerResponse
+  >;
 
   constructor(options: ModernServerOptions) {
     super(options);
@@ -76,7 +74,9 @@ export class ModernDevServer extends ModernServer {
 
     // set dev server options, like webpack-dev-server
     this.dev =
-      typeof options.dev === 'boolean' ? DEFAULT_DEV_OPTIONS : options.dev!;
+      typeof options.dev === 'boolean'
+        ? DEFAULT_DEV_OPTIONS
+        : { ...DEFAULT_DEV_OPTIONS, ...options.dev };
 
     enableRegister(this.pwd, this.conf);
   }
@@ -124,7 +124,9 @@ export class ModernDevServer extends ModernServer {
     await super.init(runner);
 
     // watch mock/ server/ api/ dir file change
-    this.startWatcher();
+    if (this.dev.watch) {
+      this.startWatcher();
+    }
   }
 
   public ready(options: ReadyOptions = {}) {
@@ -239,7 +241,7 @@ export class ModernDevServer extends ModernServer {
     const bundles = this.router.getBundles();
 
     bundles.forEach(bundle => {
-      const filepath = path.join(distDir, bundle!);
+      const filepath = path.join(distDir, bundle as string);
       if (require.cache[filepath]) {
         delete require.cache[filepath];
       }

package/src/server/dev-server/index.ts

@@ -1,2 +1,2 @@
-export { APIModernDevServer, WebModernDevServer } from './dev-server-split';
+export { ModernAPIDevServer, ModernSSRDevServer } from './dev-server-split';
 export { ModernDevServer } from './dev-server';

package/src/server/index.ts

@@ -12,9 +12,13 @@ import {
 } from '@modern-js/core';
 import { ModernServer } from './modern-server';
 import type { ModernDevServer } from './dev-server';
-import { APIModernServer, WebModernServer } from './modern-server-split';
+import {
+  ModernAPIServer,
+  ModernSSRServer,
+  ModernWebServer,
+} from './modern-server-split';
 import { ModernServerOptions, ServerHookRunner, ReadyOptions } from '@/type';
-import { measure as defaultMeasure } from '@/libs/measure';
+import { metrics as defaultMetrics } from '@/libs/metrics';
 
 export class Server {
   public options: ModernServerOptions;
@@ -44,7 +48,7 @@ export class Server {
     const { options } = this;
 
     options.logger = options.logger || defaultLogger;
-    options.measure = options.measure || defaultMeasure;
+    options.metrics = options.metrics || defaultMetrics;
 
     // initialize server
     if (options.dev) {
@@ -90,9 +94,11 @@ export class Server {
     const { options } = this;
 
     if (options.apiOnly) {
-      return new APIModernServer(options);
+      return new ModernAPIServer(options);
+    } else if (options.ssrOnly) {
+      return new ModernSSRServer(options);
     } else if (options.webOnly) {
-      return new WebModernServer(options);
+      return new ModernWebServer(options);
     } else {
       return new ModernServer(options);
     }
@@ -101,15 +107,15 @@ export class Server {
   private createDevServer() {
     const { options } = this;
     const {
-      APIModernDevServer,
-      WebModernDevServer,
+      ModernAPIDevServer,
+      ModernSSRDevServer,
       ModernDevServer,
     } = require('./dev-server');
 
     if (options.apiOnly) {
-      return new APIModernDevServer(options);
-    } else if (options.webOnly) {
-      return new WebModernDevServer(options);
+      return new ModernAPIDevServer(options);
+    } else if (options.ssrOnly) {
+      return new ModernSSRDevServer(options);
     } else {
       return new ModernDevServer(options);
     }
@@ -117,6 +123,11 @@ export class Server {
 
   private async createHookRunner() {
     const { options } = this;
+
+    options.plugins?.forEach(p => {
+      serverManager.usePlugin(p);
+    });
+
     const appContext = await this.initAppContext();
     serverManager.run(() => {
       ConfigContext.set(this.options.config as UserConfig);
@@ -129,10 +140,6 @@ export class Server {
       });
     });
 
-    options.plugins?.forEach(p => {
-      serverManager.usePlugin(p);
-    });
-
     return serverManager.init({});
   }