@modern-js/prod-server 1.22.1 → 2.0.0-alpha.0

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

@@ -1,38 +1,89 @@
-const _excluded = ["getMiddlewares"];
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-/* eslint-disable max-lines */
-import { createServer } from 'http';
-import util from 'util';
-import path from 'path';
-import { fs, mime, ROUTE_SPEC_FILE } from '@modern-js/utils';
-import axios from 'axios';
-import { clone } from '@modern-js/utils/lodash';
-import { RouteMatchManager } from "../libs/route";
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { createServer } from "http";
+import path from "path";
+import { fs, isPromise, mime, ROUTE_SPEC_FILE } from "@modern-js/utils";
+import {
+  RouteMatchManager
+} from "../libs/route";
 import { createRenderHandler } from "../libs/render";
-import { createStaticFileHandler } from "../libs/serve-file";
-import { createErrorDocument, createMiddlewareCollecter, getStaticReg, mergeExtension, noop, debug, isRedirect } from "../utils";
+import {
+  createStaticFileHandler,
+  faviconFallbackHandler
+} from "../libs/serve-file";
+import {
+  createErrorDocument,
+  createMiddlewareCollecter,
+  getStaticReg,
+  mergeExtension,
+  noop,
+  debug,
+  isRedirect
+} from "../utils";
 import * as reader from "../libs/render/reader";
 import { createProxyHandler } from "../libs/proxy";
 import { createContext } from "../libs/context";
-import { AGGRED_DIR, ERROR_DIGEST, ERROR_PAGE_TEXT, RUN_MODE } from "../constants";
-import { createTemplateAPI } from "../libs/hook-api/template";
-import { createRouteAPI } from "../libs/hook-api/route";
-const API_DIR = './api';
-const SERVER_DIR = './server';
-export class ModernServer {
-  // appDirectory
-  // product dist dir
-  // work on src or dist
+import { templateInjectableStream } from "../libs/hook-api/template";
+import {
+  AGGRED_DIR,
+  ERROR_DIGEST,
+  ERROR_PAGE_TEXT,
+  RUN_MODE
+} from "../constants";
+import {
+  createAfterMatchContext,
+  createAfterRenderContext,
+  createMiddlewareContext
+} from "../libs/hook-api";
+const API_DIR = "./api";
+const SERVER_DIR = "./server";
+class ModernServer {
   constructor({
     pwd,
     config,
@@ -43,616 +94,455 @@ export class ModernServer {
     runMode,
     proxyTarget
   }) {
-    var _config$output;
-
-    _defineProperty(this, "pwd", void 0);
-
-    _defineProperty(this, "distDir", void 0);
-
-    _defineProperty(this, "workDir", void 0);
-
-    _defineProperty(this, "router", void 0);
-
-    _defineProperty(this, "conf", void 0);
-
-    _defineProperty(this, "handlers", []);
-
-    _defineProperty(this, "presetRoutes", void 0);
-
-    _defineProperty(this, "runner", void 0);
-
-    _defineProperty(this, "logger", void 0);
-
-    _defineProperty(this, "metrics", void 0);
-
-    _defineProperty(this, "runMode", void 0);
-
-    _defineProperty(this, "reader", reader);
-
-    _defineProperty(this, "proxyTarget", void 0);
-
-    _defineProperty(this, "staticFileHandler", void 0);
-
-    _defineProperty(this, "routeRenderHandler", void 0);
-
-    _defineProperty(this, "frameWebHandler", null);
-
-    _defineProperty(this, "frameAPIHandler", null);
-
-    _defineProperty(this, "proxyHandler", null);
-
-    _defineProperty(this, "_handler", void 0);
-
-    _defineProperty(this, "staticGenerate", void 0);
-
-    require('ignore-styles');
-
+    this.handlers = [];
+    this.reader = reader;
+    this.beforeRouteHandler = null;
+    this.frameWebHandler = null;
+    this.frameAPIHandler = null;
+    this.proxyHandler = null;
+    require("ignore-styles");
     this.pwd = pwd;
-    this.distDir = path.join(pwd, ((_config$output = config.output) === null || _config$output === void 0 ? void 0 : _config$output.path) || 'dist');
+    this.distDir = path.join(pwd, config.output.path || "dist");
     this.workDir = this.distDir;
     this.conf = config;
-    debug('server conf', this.conf);
+    debug("server conf", this.conf);
     this.logger = logger;
     this.metrics = metrics;
     this.router = new RouteMatchManager();
     this.presetRoutes = routes;
     this.proxyTarget = proxyTarget;
     this.staticGenerate = staticGenerate || false;
-    this.runMode = runMode || RUN_MODE.TYPE;
-    process.env.BUILD_TYPE = `${this.staticGenerate ? 'ssg' : 'ssr'}`;
-  } // server prepare
-
-
-  async onInit(runner, app) {
-    var _conf$bff;
-
-    this.runner = runner;
-    const {
-      distDir,
-      staticGenerate,
-      conf
-    } = this;
-    debug('final server conf', this.conf); // proxy handler, each proxy has own handler
-
-    this.proxyHandler = createProxyHandler((_conf$bff = conf.bff) === null || _conf$bff === void 0 ? void 0 : _conf$bff.proxy);
-
-    if (this.proxyHandler) {
-      this.proxyHandler.forEach(handler => {
-        this.addHandler(handler);
+    this.runMode = runMode || RUN_MODE.FULL;
+  }
+  onInit(runner, app) {
+    return __async(this, null, function* () {
+      var _a;
+      this.runner = runner;
+      const { distDir, staticGenerate, conf } = this;
+      debug("final server conf", this.conf);
+      this.proxyHandler = createProxyHandler((_a = conf.bff) == null ? void 0 : _a.proxy);
+      if (this.proxyHandler) {
+        this.proxyHandler.forEach((handler) => {
+          this.addHandler(handler);
+        });
+      }
+      this.reader.init();
+      app.on("close", () => {
+        this.reader.close();
+      });
+      const usageRoutes = this.filterRoutes(this.getRoutes());
+      this.router.reset(usageRoutes);
+      this.warmupSSRBundle();
+      yield this.prepareFrameHandler();
+      yield this.prepareBeforeRouteHandler(usageRoutes, distDir);
+      const staticPathRegExp = getStaticReg(
+        this.conf.output || {},
+        this.conf.html
+      );
+      this.staticFileHandler = createStaticFileHandler(
+        [
+          {
+            path: staticPathRegExp,
+            target: distDir
+          }
+        ],
+        this.conf.output
+      );
+      this.routeRenderHandler = createRenderHandler({
+        distDir,
+        staticGenerate
       });
-    } // start file reader
-
-
-    this.reader.init();
-    app.on('close', () => {
-      this.reader.close();
-    }); // use preset routes priority
-
-    const usageRoutes = this.filterRoutes(this.getRoutes());
-    this.router.reset(usageRoutes); // warmup ssr bundle in production env
-
-    this.warmupSSRBundle();
-    await this.prepareFrameHandler(); // Only work when without setting `assetPrefix`.
-    // Setting `assetPrefix` means these resources should be uploaded to CDN.
-
-    const staticPathRegExp = getStaticReg(this.conf.output || {});
-    this.staticFileHandler = createStaticFileHandler([{
-      path: staticPathRegExp,
-      target: distDir
-    }], this.conf.output);
-    this.routeRenderHandler = createRenderHandler({
-      distDir,
-      staticGenerate
+      yield this.setupBeforeProdMiddleware();
+      this.addHandler(this.staticFileHandler);
+      this.addHandler(faviconFallbackHandler);
+      this.addBeforeRouteHandler();
+      this.addHandler(this.routeHandler.bind(this));
+      this.compose();
     });
-    await this.setupBeforeProdMiddleware();
-    this.addHandler(this.staticFileHandler);
-    this.addHandler(this.routeHandler.bind(this)); // compose middlewares to http handler
-
-    this.compose();
-  } // server ready
-
-
-  onRepack(_) {// empty
   }
-
-  onServerChange({
-    filepath
-  }) {
-    const {
-      pwd
-    } = this;
-    const {
-      api,
-      server
-    } = AGGRED_DIR;
+  onRepack(_) {
+  }
+  addBeforeRouteHandler() {
+    this.addHandler((context, next) => __async(this, null, function* () {
+      if (this.beforeRouteHandler) {
+        yield this.beforeRouteHandler(context);
+        if (this.isSend(context.res)) {
+          return;
+        }
+      }
+      return next();
+    }));
+  }
+  onServerChange({ filepath }) {
+    const { pwd } = this;
+    const { api, server } = AGGRED_DIR;
     const apiPath = path.normalize(path.join(pwd, api));
     const serverPath = path.normalize(path.join(pwd, server));
     const onlyApi = filepath.startsWith(apiPath);
     const onlyWeb = filepath.startsWith(serverPath);
-    this.prepareFrameHandler({
-      onlyWeb,
-      onlyApi
-    });
-  } // exposed requestHandler
-
-
+    this.prepareFrameHandler({ onlyWeb, onlyApi });
+  }
   getRequestHandler() {
     return this.requestHandler.bind(this);
   }
-
-  async createHTTPServer(handler) {
-    return createServer(handler);
+  render(req, res, url) {
+    return __async(this, null, function* () {
+      req.logger = this.logger;
+      req.metrics = this.metrics;
+      const context = createContext(req, res);
+      const matched = this.router.match(url || context.path);
+      if (!matched) {
+        return null;
+      }
+      const route = matched.generate(context.url);
+      const result = yield this.handleWeb(context, route);
+      if (!result) {
+        return null;
+      }
+      return result.content.toString();
+    });
+  }
+  createHTTPServer(handler) {
+    return __async(this, null, function* () {
+      return createServer(handler);
+    });
   }
-  /* —————————————————————— function will be overwrite —————————————————————— */
-  // get routes info
-
-
   getRoutes() {
-    // Preferred to use preset routes
     if (this.presetRoutes) {
       return this.presetRoutes;
-    } // read routes from spec file
-
-
+    }
     const file = path.join(this.distDir, ROUTE_SPEC_FILE);
-
     if (fs.existsSync(file)) {
       const content = fs.readJSONSync(file);
       return content.routes;
     }
-
     return [];
-  } // add promisify request handler to server
-  // handler should do not do more things after invoke next
-
-
+  }
   addHandler(handler) {
-    if (handler[Symbol.toStringTag] === 'AsyncFunction') {
-      this.handlers.push(handler);
-    } else {
-      this.handlers.push(util.promisify(handler));
-    }
-  } // return 404 page
-
-
+    this.handlers.push(handler);
+  }
   render404(context) {
-    context.error(ERROR_DIGEST.ENOTF, '404 Not Found');
+    context.error(ERROR_DIGEST.ENOTF, "404 Not Found");
     this.renderErrorPage(context, 404);
-  } // gather frame extension and get framework handler
-
-
-  async prepareFrameHandler(options) {
-    const {
-      workDir,
-      runner
-    } = this;
-    const {
-      onlyApi,
-      onlyWeb
-    } = options || {}; // server hook, gather plugin inject
-
-    const _createMiddlewareColl = createMiddlewareCollecter(),
-          {
-      getMiddlewares
-    } = _createMiddlewareColl,
-          collector = _objectWithoutProperties(_createMiddlewareColl, _excluded);
-
-    await runner.gather(collector);
-    const {
-      api: pluginAPIExt,
-      web: pluginWebExt
-    } = getMiddlewares();
-    const apiDir = path.join(workDir, API_DIR);
-    const serverDir = path.join(workDir, SERVER_DIR); // get api or web server handler from server-framework plugin
-
-    if ((await fs.pathExists(path.join(serverDir))) && !onlyApi) {
-      const webExtension = mergeExtension(pluginWebExt);
-      this.frameWebHandler = await this.prepareWebHandler(webExtension);
-    }
-
-    if (fs.existsSync(apiDir) && !onlyWeb) {
-      const apiExtension = mergeExtension(pluginAPIExt);
-      this.frameAPIHandler = await this.prepareAPIHandler(apiExtension);
-    }
   }
-
-  async prepareWebHandler(extension) {
-    const {
-      workDir,
-      runner
-    } = this;
-    return runner.prepareWebServer({
-      pwd: workDir,
-      config: extension
-    }, {
-      onLast: () => null
+  prepareBeforeRouteHandler(specs, distDir) {
+    return __async(this, null, function* () {
+      const { runner } = this;
+      const handler = yield runner.preparebeforeRouteHandler(
+        {
+          serverRoutes: specs,
+          distDir
+        },
+        {
+          onLast: () => null
+        }
+      );
+      this.beforeRouteHandler = handler;
+    });
+  }
+  prepareFrameHandler(options) {
+    return __async(this, null, function* () {
+      const { workDir, runner } = this;
+      const { onlyApi, onlyWeb } = options || {};
+      const _a = createMiddlewareCollecter(), { getMiddlewares } = _a, collector = __objRest(_a, ["getMiddlewares"]);
+      yield runner.gather(collector);
+      const { api: pluginAPIExt, web: pluginWebExt } = getMiddlewares();
+      const apiDir = path.join(workDir, API_DIR);
+      const serverDir = path.join(workDir, SERVER_DIR);
+      if ((yield fs.pathExists(path.join(serverDir))) && !onlyApi) {
+        const webExtension = mergeExtension(pluginWebExt);
+        this.frameWebHandler = yield this.prepareWebHandler(webExtension);
+      }
+      if (fs.existsSync(apiDir) && !onlyWeb) {
+        const apiExtension = mergeExtension(pluginAPIExt);
+        this.frameAPIHandler = yield this.prepareAPIHandler(apiExtension);
+      }
+    });
+  }
+  prepareWebHandler(extension) {
+    return __async(this, null, function* () {
+      const { workDir, runner } = this;
+      const handler = yield runner.prepareWebServer(
+        {
+          pwd: workDir,
+          config: extension
+        },
+        { onLast: () => null }
+      );
+      return handler;
     });
   }
-
-  async prepareAPIHandler(extension) {
-    const {
-      workDir,
-      runner,
-      conf
-    } = this;
-    const {
-      bff
-    } = conf;
-    const prefix = (bff === null || bff === void 0 ? void 0 : bff.prefix) || '/api';
-    return runner.prepareApiServer({
-      pwd: workDir,
-      config: extension,
-      prefix: Array.isArray(prefix) ? prefix[0] : prefix
-    }, {
-      onLast: () => null
+  prepareAPIHandler(extension) {
+    return __async(this, null, function* () {
+      const { workDir, runner, conf } = this;
+      const { bff } = conf;
+      const prefix = (bff == null ? void 0 : bff.prefix) || "/api";
+      return runner.prepareApiServer(
+        {
+          pwd: workDir,
+          config: extension,
+          prefix: Array.isArray(prefix) ? prefix[0] : prefix
+        },
+        { onLast: () => null }
+      );
     });
   }
-
   filterRoutes(routes) {
     return routes;
   }
-
-  async emitRouteHook(eventName, input) {
-    input.context = clone(input.context);
-    return this.runner[eventName](input, {
-      onLast: noop
+  setupBeforeProdMiddleware() {
+    return __async(this, null, function* () {
+      const { conf, runner } = this;
+      const preMiddleware = yield runner.beforeProdServer(conf);
+      preMiddleware.flat().forEach((mid) => {
+        this.addHandler(mid);
+      });
     });
   }
-
-  async setupBeforeProdMiddleware() {
-    const {
-      conf,
-      runner
-    } = this;
-    const preMiddleware = await runner.beforeProdServer(conf);
-    preMiddleware.flat().forEach(mid => {
-      this.addHandler(mid);
+  handleAPI(context) {
+    return __async(this, null, function* () {
+      const { req, res } = context;
+      if (!this.frameAPIHandler) {
+        throw new Error("can not found api handler");
+      }
+      yield this.frameAPIHandler(req, res);
     });
   }
-
-  async handleAPI(context) {
-    const {
-      req,
-      res
-    } = context;
-
-    if (!this.frameAPIHandler) {
-      throw new Error('can not found api handler');
-    }
-
-    await this.frameAPIHandler(req, res);
+  handleWeb(context, route) {
+    return __async(this, null, function* () {
+      return this.routeRenderHandler({
+        ctx: context,
+        route,
+        runner: this.runner
+      });
+    });
   }
-
-  async handleWeb(context, route) {
-    return this.routeRenderHandler({
-      ctx: context,
-      route,
-      runner: this.runner
+  proxy() {
+    return __async(this, null, function* () {
+      return null;
     });
   }
-
-  async proxy() {
-    return null;
-  } // warmup ssr function
-
-
   warmupSSRBundle() {
-    const {
-      distDir
-    } = this;
+    const { distDir } = this;
     const bundles = this.router.getBundles();
-    bundles.forEach(bundle => {
-      const filepath = path.join(distDir, bundle); // if error, just throw and let process die
-
+    bundles.forEach((bundle) => {
+      const filepath = path.join(distDir, bundle);
       require(filepath);
     });
   }
-
   createContext(req, res, options = {}) {
     return createContext(req, res, options);
   }
-  /* —————————————————————— private function —————————————————————— */
-  // handler route.json, include api / csr / ssr
-
-
-  async routeHandler(context) {
-    const {
-      req,
-      res
-    } = context;
-    await this.emitRouteHook('beforeMatch', {
-      context
-    }); // match routes in the route spec
-
-    const matched = this.router.match(context.path);
-
-    if (!matched) {
-      this.render404(context);
-      return;
-    }
-
-    if (res.headersSent) {
-      return;
-    }
-
-    const routeAPI = createRouteAPI(matched, this.router, context.url);
-    await this.emitRouteHook('afterMatch', {
-      context,
-      routeAPI
-    });
-
-    if (this.isSend(res)) {
-      return;
-    }
-
-    const {
-      current
-    } = routeAPI;
-    const route = current.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);
-    } // frameWebHandler has process request
-
-
-    if (this.isSend(res)) {
-      return;
-    }
-
-    if (route.responseHeaders) {
-      Object.keys(route.responseHeaders).forEach(key => {
-        const value = route.responseHeaders[key];
-
-        if (value) {
-          context.res.setHeader(key, value);
+  routeHandler(context) {
+    return __async(this, null, function* () {
+      const { res } = context;
+      const matched = this.router.match(context.path);
+      if (!matched) {
+        this.render404(context);
+        return;
+      }
+      let route = matched.generate(context.url);
+      if (route.isApi) {
+        yield this.handleAPI(context);
+        return;
+      }
+      const afterMatchContext = createAfterMatchContext(context, route.entryName);
+      if (this.runMode === RUN_MODE.FULL) {
+        yield this.runner.afterMatch(afterMatchContext, { onLast: noop });
+      }
+      if (this.isSend(res)) {
+        return;
+      }
+      const { current, url, status } = afterMatchContext.router;
+      if (url) {
+        this.redirect(res, url, status);
+        return;
+      }
+      if (route.entryName !== current) {
+        const matched2 = this.router.matchEntry(current);
+        if (!matched2) {
+          this.render404(context);
+          return;
         }
+        route = matched2.generate(context.url);
+      }
+      context.setParams(route.params);
+      context.setServerData("router", {
+        baseUrl: route.urlPath,
+        params: route.params
       });
-    }
-
-    if (route.entryName) {
-      await this.emitRouteHook('beforeRender', {
-        context
-      });
-    }
-
-    const file = await this.handleWeb(context, route);
-
-    if (!file) {
-      this.render404(context);
-      return;
-    }
-
-    if (file.redirect) {
-      res.statusCode = file.statusCode;
-      res.setHeader('Location', file.content);
-      res.end();
-      return;
-    }
-
-    if (this.isSend(res)) {
-      return;
-    }
-
-    let response = file.content;
-
-    if (route.entryName) {
-      const templateAPI = createTemplateAPI(file.content.toString());
-      await this.emitRouteHook('afterRender', {
-        context,
-        templateAPI
-      });
-
+      if (this.frameWebHandler) {
+        res.locals = res.locals || {};
+        const middlewareContext = createMiddlewareContext(context);
+        yield this.frameWebHandler(middlewareContext);
+        res.locals = __spreadValues(__spreadValues({}, res.locals), middlewareContext.response.locals);
+      }
       if (this.isSend(res)) {
         return;
       }
-
-      await this.injectMicroFE(context, templateAPI); // 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();
-    }
-
-    res.setHeader('content-type', file.contentType);
-    res.end(response);
+      if (route.responseHeaders) {
+        Object.keys(route.responseHeaders).forEach((key) => {
+          const value = route.responseHeaders[key];
+          if (value) {
+            context.res.setHeader(key, value);
+          }
+        });
+      }
+      const renderResult = yield this.handleWeb(context, route);
+      if (!renderResult) {
+        this.render404(context);
+        return;
+      }
+      if (renderResult.redirect) {
+        this.redirect(
+          res,
+          renderResult.content,
+          renderResult.statusCode
+        );
+        return;
+      }
+      if (this.isSend(res)) {
+        return;
+      }
+      res.setHeader("content-type", renderResult.contentType);
+      const { contentStream } = renderResult;
+      if (contentStream) {
+        contentStream.pipe(
+          templateInjectableStream({
+            prependHead: route.entryName ? `<script>window._SERVER_DATA=${JSON.stringify(
+              context.serverData
+            )}<\/script>` : void 0
+          })
+        ).pipe(res);
+        return;
+      }
+      let response = renderResult.content;
+      if (route.entryName) {
+        const afterRenderContext = createAfterRenderContext(
+          context,
+          response.toString()
+        );
+        if (this.runMode === RUN_MODE.FULL) {
+          yield this.runner.afterRender(afterRenderContext, { onLast: noop });
+        }
+        if (this.isSend(res)) {
+          return;
+        }
+        afterRenderContext.template.prependHead(
+          `<script>window._SERVER_DATA=${JSON.stringify(
+            context.serverData
+          )}<\/script>`
+        );
+        response = afterRenderContext.template.get();
+      }
+      res.end(response);
+    });
   }
-
   isSend(res) {
     if (res.headersSent) {
       return true;
     }
-
-    if (res.getHeader('Location') && isRedirect(res.statusCode)) {
+    if (res.getHeader("Location") && isRedirect(res.statusCode)) {
       res.end();
       return true;
     }
-
     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.get(moduleRequestUrl);
-
-        if (Array.isArray(remoteModules)) {
-          modules.push(...remoteModules);
-        }
-      } catch (e) {
-        context.error(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(ERROR_DIGEST.EMICROINJ, e);
-    }
-  } // compose handlers and create the final handler
-
-
   compose() {
-    const {
-      handlers
-    } = this;
-
+    const { handlers } = this;
     if (!Array.isArray(handlers)) {
-      throw new TypeError('Middleware stack must be an array!');
+      throw new TypeError("Middleware stack must be an array!");
     }
-
     for (const fn of handlers) {
-      if (typeof fn !== 'function') {
-        throw new TypeError('Middleware must be composed of functions!');
+      if (typeof fn !== "function") {
+        throw new TypeError("Middleware must be composed of functions!");
       }
     }
-
     this._handler = (context, next) => {
       let i = 0;
-
-      const dispatch = error => {
+      const dispatch = (error) => {
         if (error) {
           return this.onError(context, error);
         }
-
         const handler = handlers[i++];
-
         if (!handler) {
           return next();
         }
-
-        return handler(context, dispatch).catch(onError);
+        try {
+          const result = handler(context, dispatch);
+          if (isPromise(result)) {
+            return result.catch(onError);
+          }
+        } catch (e) {
+          return onError(e);
+        }
       };
-
-      const onError = err => {
+      const onError = (err) => {
         this.onError(context, err);
       };
-
       return dispatch();
     };
   }
-
-  requestHandler(req, res, next = () => {// empty
+  requestHandler(req, res, next = () => {
   }) {
     res.statusCode = 200;
     req.logger = this.logger;
     req.metrics = this.metrics;
     let context;
-
     try {
       context = this.createContext(req, res);
     } catch (e) {
       this.logger.error(e);
       res.statusCode = 500;
-      res.setHeader('content-type', mime.contentType('html'));
+      res.setHeader("content-type", mime.contentType("html"));
       return res.end(createErrorDocument(500, ERROR_PAGE_TEXT[500]));
     }
-
     try {
       return this._handler(context, next);
     } catch (err) {
       return this.onError(context, err);
     }
   }
-
+  redirect(res, url, status = 302) {
+    res.setHeader("Location", url);
+    res.statusCode = status;
+    res.end();
+  }
   onError(context, err) {
     context.error(ERROR_DIGEST.EINTER, err);
     this.renderErrorPage(context, 500);
   }
-
-  async renderErrorPage(context, status) {
-    const {
-      res
-    } = context;
-    context.status = status;
-    res.setHeader('content-type', mime.contentType('html'));
-    const statusPage = `/${status}`;
-    const customErrorPage = `/_error`;
-    const matched = this.router.match(statusPage) || this.router.match(customErrorPage); // if no custom status page find
-
-    if (matched) {
-      const route = matched.generate(context.url);
-      const {
-        entryName
-      } = route; // check entryName, avoid matched '/' route
-
-      if (entryName === status.toString() || entryName === '_error') {
-        try {
-          const file = await this.routeRenderHandler({
-            route,
-            ctx: context,
-            runner: this.runner
-          });
-
-          if (file) {
-            context.res.end(file.content);
-            return;
+  renderErrorPage(context, status) {
+    return __async(this, null, function* () {
+      const { res } = context;
+      context.status = status;
+      res.setHeader("content-type", mime.contentType("html"));
+      const statusPage = `/${status}`;
+      const customErrorPage = `/_error`;
+      const matched = this.router.match(statusPage) || this.router.match(customErrorPage);
+      if (matched) {
+        const route = matched.generate(context.url);
+        const { entryName } = route;
+        if (entryName === status.toString() || entryName === "_error") {
+          try {
+            const file = yield this.routeRenderHandler({
+              route,
+              ctx: context,
+              runner: this.runner
+            });
+            if (file) {
+              context.res.end(file.content);
+              return;
+            }
+          } catch (e) {
           }
-        } catch (e) {// just catch error when the rendering error occurred in the custom error page.
         }
       }
-    }
-
-    const text = ERROR_PAGE_TEXT[status] || ERROR_PAGE_TEXT[500];
-    context.res.end(createErrorDocument(status, text));
+      const text = ERROR_PAGE_TEXT[status] || ERROR_PAGE_TEXT[500];
+      context.res.end(createErrorDocument(status, text));
+    });
   }
-
 }
-/* eslint-enable max-lines */
+export {
+  ModernServer
+};