@modern-js/prod-server 1.21.2 → 2.0.0-beta.0

package/dist/js/node/server/modern-server.js

@@ -13,10 +13,6 @@ var _path = _interopRequireDefault(require("path"));
 
 var _utils = require("@modern-js/utils");
 
-var _axios = _interopRequireDefault(require("axios"));
-
-var _lodash = require("@modern-js/utils/lodash");
-
 var _route = require("../libs/route");
 
 var _render = require("../libs/render");
@@ -31,11 +27,11 @@ var _proxy = require("../libs/proxy");
 
 var _context = require("../libs/context");
 
-var _constants = require("../constants");
-
 var _template = require("../libs/hook-api/template");
 
-var _route2 = require("../libs/hook-api/route");
+var _constants = require("../constants");
+
+var _hookApi = require("../libs/hook-api");
 
 const _excluded = ["getMiddlewares"];
 
@@ -104,6 +100,8 @@ class ModernServer {
 
     _defineProperty(this, "routeRenderHandler", void 0);
 
+    _defineProperty(this, "beforeRouteHandler", null);
+
     _defineProperty(this, "frameWebHandler", null);
 
     _defineProperty(this, "frameAPIHandler", null);
@@ -127,8 +125,7 @@ class ModernServer {
     this.presetRoutes = routes;
     this.proxyTarget = proxyTarget;
     this.staticGenerate = staticGenerate || false;
-    this.runMode = runMode || _constants.RUN_MODE.TYPE;
-    process.env.BUILD_TYPE = `${this.staticGenerate ? 'ssg' : 'ssr'}`;
+    this.runMode = runMode || _constants.RUN_MODE.FULL; // process.env.BUILD_TYPE = `${this.staticGenerate ? 'ssg' : 'ssr'}`;
   } // server prepare
 
 
@@ -161,7 +158,8 @@ class ModernServer {
     this.router.reset(usageRoutes); // warmup ssr bundle in production env
 
     this.warmupSSRBundle();
-    await this.prepareFrameHandler(); // Only work when without setting `assetPrefix`.
+    await this.prepareFrameHandler();
+    await this.prepareBeforeRouteHandler(usageRoutes, distDir); // Only work when without setting `assetPrefix`.
     // Setting `assetPrefix` means these resources should be uploaded to CDN.
 
     const staticPathRegExp = (0, _utils2.getStaticReg)(this.conf.output || {});
@@ -174,7 +172,10 @@ class ModernServer {
       staticGenerate
     });
     await this.setupBeforeProdMiddleware();
-    this.addHandler(this.staticFileHandler);
+    this.addHandler(this.staticFileHandler); // execute after staticFileHandler, can rename to staticFallbackHandler if needed.
+
+    this.addHandler(_serveFile.faviconFallbackHandler);
+    this.addBeforeRouteHandler();
     this.addHandler(this.routeHandler.bind(this)); // compose middlewares to http handler
 
     this.compose();
@@ -184,6 +185,21 @@ class ModernServer {
   onRepack(_) {// empty
   }
 
+  addBeforeRouteHandler() {
+    this.addHandler(async (context, next) => {
+      if (this.beforeRouteHandler) {
+        await this.beforeRouteHandler(context);
+
+        if (this.isSend(context.res)) {
+          return;
+        }
+      } // eslint-disable-next-line consistent-return
+
+
+      return next();
+    });
+  }
+
   onServerChange({
     filepath
   }) {
@@ -212,6 +228,26 @@ class ModernServer {
     return this.requestHandler.bind(this);
   }
 
+  async render(req, res, url) {
+    req.logger = this.logger;
+    req.metrics = this.metrics;
+    const context = (0, _context.createContext)(req, res);
+    const matched = this.router.match(url || context.path);
+
+    if (!matched) {
+      return null;
+    }
+
+    const route = matched.generate(context.url);
+    const result = await this.handleWeb(context, route);
+
+    if (!result) {
+      return null;
+    }
+
+    return result.content.toString();
+  }
+
   async createHTTPServer(handler) {
     return (0, _http.createServer)(handler);
   }
@@ -251,6 +287,19 @@ class ModernServer {
   render404(context) {
     context.error(_constants.ERROR_DIGEST.ENOTF, '404 Not Found');
     this.renderErrorPage(context, 404);
+  }
+
+  async prepareBeforeRouteHandler(specs, distDir) {
+    const {
+      runner
+    } = this;
+    const handler = await runner.preparebeforeRouteHandler({
+      serverRoutes: specs,
+      distDir
+    }, {
+      onLast: () => null
+    });
+    this.beforeRouteHandler = handler;
   } // gather frame extension and get framework handler
 
 
@@ -297,12 +346,13 @@ class ModernServer {
       workDir,
       runner
     } = this;
-    return runner.prepareWebServer({
+    const handler = await runner.prepareWebServer({
       pwd: workDir,
       config: extension
     }, {
       onLast: () => null
     });
+    return handler;
   }
 
   async prepareAPIHandler(extension) {
@@ -328,13 +378,6 @@ class ModernServer {
     return routes;
   }
 
-  async emitRouteHook(eventName, input) {
-    input.context = (0, _lodash.clone)(input.context);
-    return this.runner[eventName](input, {
-      onLast: _utils2.noop
-    });
-  }
-
   async setupBeforeProdMiddleware() {
     const {
       conf,
@@ -394,51 +437,70 @@ class ModernServer {
 
   async routeHandler(context) {
     const {
-      req,
       res
-    } = context;
-    await this.emitRouteHook('beforeMatch', {
-      context
-    }); // match routes in the route spec
+    } = context; // match routes in the route spec
 
     const matched = this.router.match(context.path);
 
     if (!matched) {
       this.render404(context);
       return;
-    }
+    } // route is api service
 
-    if (res.headersSent) {
+
+    let route = matched.generate(context.url);
+
+    if (route.isApi) {
+      await this.handleAPI(context);
       return;
     }
 
-    const routeAPI = (0, _route2.createRouteAPI)(matched, this.router, context.url);
-    await this.emitRouteHook('afterMatch', {
-      context,
-      routeAPI
-    });
+    const afterMatchContext = (0, _hookApi.createAfterMatchContext)(context, route.entryName); // only full mode run server hook
+
+    if (this.runMode === _constants.RUN_MODE.FULL) {
+      await this.runner.afterMatch(afterMatchContext, {
+        onLast: _utils2.noop
+      });
+    }
 
     if (this.isSend(res)) {
       return;
     }
 
     const {
-      current
-    } = routeAPI;
-    const route = current.generate(context.url);
+      current,
+      url,
+      status
+    } = afterMatchContext.router; // redirect to another url
+
+    if (url) {
+      this.redirect(res, url, status);
+      return;
+    } // rewrite to another entry
+
+
+    if (route.entryName !== current) {
+      const matched = this.router.matchEntry(current);
+
+      if (!matched) {
+        this.render404(context);
+        return;
+      }
+
+      route = matched.generate(context.url);
+    }
+
     context.setParams(route.params);
     context.setServerData('router', {
       baseUrl: route.urlPath,
       params: route.params
-    }); // route is api service
-
-    if (route.isApi) {
-      await this.handleAPI(context);
-      return;
-    }
+    });
 
     if (this.frameWebHandler) {
-      await this.frameWebHandler(req, res);
+      res.locals = res.locals || {};
+      const middlewareContext = (0, _hookApi.createMiddlewareContext)(context);
+      await this.frameWebHandler(middlewareContext);
+      res.locals = _objectSpread(_objectSpread({}, res.locals), middlewareContext.response.locals);
     } // frameWebHandler has process request
 
 
@@ -456,23 +518,16 @@ class ModernServer {
       });
     }
 
-    if (route.entryName) {
-      await this.emitRouteHook('beforeRender', {
-        context
-      });
-    }
-
-    const file = await this.handleWeb(context, route);
+    const renderResult = await this.handleWeb(context, route);
 
-    if (!file) {
+    if (!renderResult) {
       this.render404(context);
       return;
-    }
+    } // React Router navigation
 
-    if (file.redirect) {
-      res.statusCode = file.statusCode;
-      res.setHeader('Location', file.content);
-      res.end();
+
+    if (renderResult.redirect) {
+      this.redirect(res, renderResult.content, renderResult.statusCode);
       return;
     }
 
@@ -480,29 +535,42 @@ class ModernServer {
       return;
     }
 
-    let response = file.content;
+    res.setHeader('content-type', renderResult.contentType);
+    const {
+      contentStream
+    } = renderResult;
+
+    if (contentStream) {
+      contentStream.pipe((0, _template.templateInjectableStream)({
+        prependHead: route.entryName ? `<script>window._SERVER_DATA=${JSON.stringify(context.serverData)}</script>` : undefined
+      })).pipe(res);
+      return;
+    }
+
+    let response = renderResult.content;
 
     if (route.entryName) {
-      const templateAPI = (0, _template.createTemplateAPI)(file.content.toString());
-      await this.emitRouteHook('afterRender', {
-        context,
-        templateAPI
-      });
+      const afterRenderContext = (0, _hookApi.createAfterRenderContext)(context, response.toString()); // only full mode run server hook
+      // FIXME: how to run server hook in streaming
 
-      if (this.isSend(res)) {
-        return;
+      if (this.runMode === _constants.RUN_MODE.FULL) {
+        await this.runner.afterRender(afterRenderContext, {
+          onLast: _utils2.noop
+        });
       }
 
-      await this.injectMicroFE(context, templateAPI); // It will inject _SERVER_DATA twice, when SSG mode.
+      if (this.isSend(res)) {
+        return;
+      } // It will inject _SERVER_DATA twice, when SSG mode.
       // The first time was in ssg html created, the seoncd time was in prod-server start.
       // but the second wound causes route error.
       // To ensure that the second injection fails, the _SERVER_DATA inject at the front of head,
 
-      templateAPI.prependHead(`<script>window._SERVER_DATA=${JSON.stringify(context.serverData)}</script>`);
-      response = templateAPI.get();
+
+      afterRenderContext.template.prependHead(`<script>window._SERVER_DATA=${JSON.stringify(context.serverData)}</script>`);
+      response = afterRenderContext.template.get();
     }
 
-    res.setHeader('content-type', file.contentType);
     res.end(response);
   }
 
@@ -517,72 +585,6 @@ class ModernServer {
     }
 
     return false;
-  }
-
-  async injectMicroFE(context, templateAPI) {
-    var _conf$runtime, _conf$server;
-
-    const {
-      conf
-    } = this;
-    const masterApp = (_conf$runtime = conf.runtime) === null || _conf$runtime === void 0 ? void 0 : _conf$runtime.masterApp; // no inject if not master App
-
-    if (!masterApp) {
-      return;
-    }
-
-    const manifest = masterApp.manifest || {};
-    let modules = [];
-    const {
-      modules: configModules = []
-    } = manifest; // while config modules is an string, fetch data from remote
-
-    if (typeof configModules === 'string') {
-      const moduleRequestUrl = configModules;
-
-      try {
-        const {
-          data: remoteModules
-        } = await _axios.default.get(moduleRequestUrl);
-
-        if (Array.isArray(remoteModules)) {
-          modules.push(...remoteModules);
-        }
-      } catch (e) {
-        context.error(_constants.ERROR_DIGEST.EMICROINJ, e);
-      }
-    } else if (Array.isArray(configModules)) {
-      modules.push(...configModules);
-    }
-
-    const {
-      headers
-    } = context.req;
-    const debugName = headers['x-micro-frontend-module-name'] || context.query['__debug__micro-frontend-module-name'];
-    const debugEntry = headers['x-micro-frontend-module-entry'] || context.query['__debug__micro-frontend-module-entry']; // add debug micro App to first
-
-    if (debugName && debugEntry && (_conf$server = conf.server) !== null && _conf$server !== void 0 && _conf$server.enableMicroFrontendDebug) {
-      modules = modules.map(m => {
-        if (m.name === debugName) {
-          return {
-            name: debugName,
-            entry: debugEntry
-          };
-        }
-
-        return m;
-      });
-    }
-
-    try {
-      // Todo Safety xss
-      const injection = JSON.stringify(_objectSpread(_objectSpread({}, manifest), {}, {
-        modules
-      }));
-      templateAPI.appendHead(`<script>window.modern_manifest=${injection}</script>`);
-    } catch (e) {
-      context.error(_constants.ERROR_DIGEST.EMICROINJ, e);
-    }
   } // compose handlers and create the final handler
 
 
@@ -649,6 +651,12 @@ class ModernServer {
     }
   }
 
+  redirect(res, url, status = 302) {
+    res.setHeader('Location', url);
+    res.statusCode = status;
+    res.end();
+  }
+
   onError(context, err) {
     context.error(_constants.ERROR_DIGEST.EINTER, err);
     this.renderErrorPage(context, 500);

package/dist/types/libs/hook-api/index.d.ts

@@ -0,0 +1,5 @@
+import type { ModernServerContext, HookContext, AfterMatchContext, AfterRenderContext, MiddlewareContext } from '@modern-js/types';
+export declare const base: (context: ModernServerContext) => HookContext;
+export declare const createAfterMatchContext: (context: ModernServerContext, entryName: string) => AfterMatchContext;
+export declare const createAfterRenderContext: (context: ModernServerContext, content: string) => AfterRenderContext;
+export declare const createMiddlewareContext: (context: ModernServerContext) => MiddlewareContext;

package/dist/types/libs/hook-api/route.d.ts

@@ -1,14 +1,9 @@
-import { RouteMatchManager, RouteMatcher } from '../route';
-
-declare class RouteAPI {
-  private readonly router;
-  private current;
-  private readonly url;
-  constructor(matched: RouteMatcher, router: RouteMatchManager, url: string);
-  cur(): import("../route").ModernRoute;
-  get(entryName: string): import("../route").ModernRoute | null;
-  use(entryName: string): boolean;
-}
-
-export declare const createRouteAPI: (matched: RouteMatcher, router: RouteMatchManager, url: string) => RouteAPI;
-export {};
+export declare class RouteAPI {
+  current: string;
+  status: number;
+  url: string;
+  constructor(entryName: string);
+  redirect(url: string, status?: number): void;
+  rewrite(entryName: string): void;
+  use(entryName: string): void;
+}

package/dist/types/libs/hook-api/template.d.ts

@@ -1,14 +1,24 @@
-declare class TemplateAPI {
+/// <reference types="node" />
+import { Transform } from 'stream';
+export declare class TemplateAPI {
   private content;
   constructor(content: string);
   get(): string;
   set(content: string): void;
-  prependHead(fragment: string): this;
-  appendHead(fragment: string): this;
-  prependBody(fragment: string): this;
-  appendBody(fragment: string): this;
-  replace(reg: RegExp | string, text: string): this;
+  prependHead(fragment: string): void;
+  appendHead(fragment: string): void;
+  prependBody(fragment: string): void;
+  appendBody(fragment: string): void;
+  private replace;
 }
-
-export declare const createTemplateAPI: (content: string) => TemplateAPI;
-export {};
+export declare const templateInjectableStream: ({
+  prependHead,
+  appendHead,
+  prependBody,
+  appendBody
+}: {
+  prependHead?: string | undefined;
+  appendHead?: string | undefined;
+  prependBody?: string | undefined;
+  appendBody?: string | undefined;
+}) => Transform;

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

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

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

@@ -1,4 +1,6 @@
 /// <reference types="react" />
+/// <reference types="node" />
+import { Writable, Readable } from 'stream';
 import { BaseSSRServerContext } from '@modern-js/types';
 declare type MetaKeyMap = {
   header?: string[];
@@ -30,5 +32,5 @@ 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 declare type RenderFunction = (context: SSRServerContext) => Promise<string | ((writable: Writable) => Promise<Readable>)>;
 export {};

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

@@ -1,9 +1,10 @@
 import { ServerOptions } from '@modern-js/server-core';
 import type { ModernServerContext } from '@modern-js/types';
-import { NextFunction } from '../type';
+import { NextFunction, ModernServerHandler } from '../type';
 declare type Rule = {
   path: string | RegExp;
   target: string;
 };
+export declare const faviconFallbackHandler: ModernServerHandler;
 export declare const createStaticFileHandler: (rules: Rule[], output?: ServerOptions['output']) => (context: ModernServerContext, next: NextFunction) => Promise<void>;
 export {};

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { IncomingMessage, ServerResponse } from 'http';
 import type { ListenOptions } from 'net';
 import { ModernServerOptions, ServerConstructor } from '../type';
@@ -44,6 +45,7 @@ export declare class Server {
   close(): Promise<void>;
   listen<T extends number | ListenOptions | undefined>(options: T, listener: any): void;
   getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
+  render(req: IncomingMessage, res: ServerResponse, url?: string): Promise<string | null>;
   private createHookRunner;
   private injectContext;
   private initAppContext;

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

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 import { IncomingMessage, ServerResponse, Server } from 'http';
-import { Adapter, APIServerStartInput, ServerOptions } from '@modern-js/server-core';
-import type { ModernServerContext } from '@modern-js/types';
+import { Adapter, WebAdapter, APIServerStartInput, ServerOptions } from '@modern-js/server-core';
+import type { ModernServerContext, ServerRoute } from '@modern-js/types';
 import type { ContextOptions } from '../libs/context';
-import { ModernServerOptions, NextFunction, ServerHookRunner, Metrics, Logger, ModernServerInterface, HookNames, BuildOptions, ModernServerHandler } from '../type';
+import { ModernServerOptions, NextFunction, ServerHookRunner, Metrics, Logger, ModernServerInterface, BuildOptions, ModernServerHandler } from '../type';
 import { RouteMatchManager, ModernRouteInterface, ModernRoute } from '../libs/route';
 import { mergeExtension } from '../utils';
 import * as reader from '../libs/render/reader';
@@ -24,6 +24,7 @@ export declare class ModernServer implements ModernServerInterface {
   protected readonly proxyTarget: ModernServerOptions['proxyTarget'];
   private staticFileHandler;
   private routeRenderHandler;
+  private beforeRouteHandler;
   private frameWebHandler;
   private frameAPIHandler;
   private proxyHandler;
@@ -41,27 +42,26 @@ export declare class ModernServer implements ModernServerInterface {
   }: ModernServerOptions);
   onInit(runner: ServerHookRunner, app: Server): Promise<void>;
   onRepack(_: BuildOptions): void;
+  addBeforeRouteHandler(): void;
   protected onServerChange({
     filepath
   }: {
     filepath: string;
   }): void;
   getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void | ServerResponse;
+  render(req: IncomingMessage, res: ServerResponse, url?: string): Promise<string | null>;
   createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server>;
-  protected getRoutes(): ModernRouteInterface[];
+  protected getRoutes(): ServerRoute[];
   protected addHandler(handler: ModernServerHandler): void;
   protected render404(context: ModernServerContext): void;
+  protected prepareBeforeRouteHandler(specs: ServerRoute[], distDir: string): Promise<void>;
   protected prepareFrameHandler(options?: {
     onlyApi: boolean;
     onlyWeb: boolean;
   }): Promise<void>;
-  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<Adapter>;
+  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<WebAdapter>;
   protected prepareAPIHandler(extension: APIServerStartInput['config']): Promise<Adapter>;
-  protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
-  protected emitRouteHook(eventName: HookNames, input: {
-    context: ModernServerContext;
-    [propsName: string]: any;
-  }): Promise<any>;
+  protected filterRoutes(routes: ModernRouteInterface[]): ServerRoute[];
   protected setupBeforeProdMiddleware(): Promise<void>;
   protected handleAPI(context: ModernServerContext): Promise<void>;
   protected handleWeb(context: ModernServerContext, route: ModernRoute): Promise<import("../type").RenderResult | null>;
@@ -70,9 +70,9 @@ export declare class ModernServer implements ModernServerInterface {
   protected createContext(req: IncomingMessage, res: ServerResponse, options?: ContextOptions): import("../libs/context").ModernServerContext;
   private routeHandler;
   private isSend;
-  private injectMicroFE;
   private compose;
   private requestHandler;
+  private redirect;
   private onError;
   private renderErrorPage;
 }

package/dist/types/type.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { IncomingMessage, Server, ServerResponse } from 'http';
+import { Readable } from 'stream';
 import { serverManager, ServerOptions } from '@modern-js/server-core';
 import type { ServerPlugin } from '@modern-js/server-core';
-import type { Metrics, Logger, NextFunction, ModernServerContext } from '@modern-js/types';
+import type { Metrics, Logger, NextFunction, ModernServerContext, InternalPlugins } from '@modern-js/types';
 import type { ModernRouteInterface } from './libs/route';
 declare module 'http' {
   interface IncomingMessage {
@@ -11,30 +13,25 @@ declare module 'http' {
     metrics: Metrics;
   }
 }
-declare type Plugin = string | [string, any] | ServerPlugin;
 export declare type ModernServerOptions = {
   pwd: string;
   config: ServerOptions;
-  plugins?: Plugin[];
+  plugins?: ServerPlugin[];
+  internalPlugins?: InternalPlugins;
   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;
-  };
   runMode?: string;
   [propName: string]: any;
 };
 export declare type RenderResult = {
   content: string | Buffer;
   contentType: string;
+  contentStream?: Readable;
   statusCode?: number;
   redirect?: boolean;
 };
@@ -49,7 +46,7 @@ export declare type BuildOptions = {
   routes?: ModernRouteInterface[];
 };
 export type { Metrics, Logger, NextFunction };
-export declare type HookNames = 'beforeMatch' | 'afterMatch' | 'beforeRender' | 'afterRender';
+export declare type HookNames = 'afterMatch' | 'afterRender';
 export interface ModernServerInterface {
   pwd: string;
   distDir: string;
@@ -57,6 +54,7 @@ export interface ModernServerInterface {
   onRepack: (options: BuildOptions) => void;
   getRequestHandler: () => (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
   createHTTPServer: (handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void) => Promise<Server>;
+  render: (req: IncomingMessage, res: ServerResponse, url?: string) => Promise<string | null>;
 }
 export declare type ServerConstructor = (options: ModernServerOptions) => ModernServerInterface;
 export declare type ModernServerHandler = (context: ModernServerContext, next: NextFunction) => Promise<void> | void;