@modern-js/prod-server 1.21.5 → 2.0.0-beta.1

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

@@ -1,38 +1,33 @@
 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";
 import { createRenderHandler } from "../libs/render";
-import { createStaticFileHandler } from "../libs/serve-file";
+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 { templateInjectableStream } from "../libs/hook-api/template";
 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";
+import { createAfterMatchContext, createAfterRenderContext, createMiddlewareContext } from "../libs/hook-api";
 const API_DIR = './api';
 const SERVER_DIR = './server';
 export class ModernServer {
   // appDirectory
+
   // product dist dir
+
   // work on src or dist
+
   constructor({
     pwd,
     config,
@@ -44,49 +39,28 @@ export class ModernServer {
     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, "beforeRouteHandler", null);
     _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.pwd = pwd;
     this.distDir = path.join(pwd, ((_config$output = config.output) === null || _config$output === void 0 ? void 0 : _config$output.path) || 'dist');
     this.workDir = this.distDir;
@@ -98,43 +72,45 @@ export class ModernServer {
     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
-
+    this.runMode = runMode || RUN_MODE.FULL;
+    // 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
-
+    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);
       });
-    } // start file reader
-
+    }
 
+    // start file reader
     this.reader.init();
     app.on('close', () => {
       this.reader.close();
-    }); // use preset routes priority
+    });
 
+    // use preset routes priority
     const usageRoutes = this.filterRoutes(this.getRoutes());
-    this.router.reset(usageRoutes); // warmup ssr bundle in production env
+    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.
+    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 = getStaticReg(this.conf.output || {});
     this.staticFileHandler = createStaticFileHandler([{
       path: staticPathRegExp,
@@ -146,15 +122,32 @@ export class ModernServer {
     });
     await this.setupBeforeProdMiddleware();
     this.addHandler(this.staticFileHandler);
-    this.addHandler(this.routeHandler.bind(this)); // compose middlewares to http handler
-
-    this.compose();
-  } // server ready
 
+    // execute after staticFileHandler, can rename to staticFallbackHandler if needed.
+    this.addHandler(faviconFallbackHandler);
+    this.addBeforeRouteHandler();
+    this.addHandler(this.routeHandler.bind(this));
 
-  onRepack(_) {// empty
+    // compose middlewares to http handler
+    this.compose();
   }
 
+  // server ready
+  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
   }) {
@@ -173,54 +166,77 @@ export class ModernServer {
       onlyWeb,
       onlyApi
     });
-  } // exposed requestHandler
-
+  }
 
+  // exposed requestHandler
   getRequestHandler() {
     return this.requestHandler.bind(this);
   }
-
+  async render(req, res, url) {
+    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 = await this.handleWeb(context, route);
+    if (!result) {
+      return null;
+    }
+    return result.content.toString();
+  }
   async createHTTPServer(handler) {
     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
-
+    }
 
+    // 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
-
+  }
 
+  // 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
-
+  }
 
+  // return 404 page
   render404(context) {
     context.error(ERROR_DIGEST.ENOTF, '404 Not Found');
     this.renderErrorPage(context, 404);
-  } // gather frame extension and get framework handler
-
+  }
+  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
   async prepareFrameHandler(options) {
     const {
       workDir,
@@ -229,46 +245,45 @@ export class ModernServer {
     const {
       onlyApi,
       onlyWeb
-    } = options || {}; // server hook, gather plugin inject
+    } = options || {};
 
+    // server hook, gather plugin inject
     const _createMiddlewareColl = createMiddlewareCollecter(),
-          {
-      getMiddlewares
-    } = _createMiddlewareColl,
-          collector = _objectWithoutProperties(_createMiddlewareColl, _excluded);
-
+      {
+        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
+    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({
+    const handler = await runner.prepareWebServer({
       pwd: workDir,
       config: extension
     }, {
       onLast: () => null
     });
+    return handler;
   }
-
   async prepareAPIHandler(extension) {
     const {
       workDir,
@@ -287,18 +302,9 @@ export class ModernServer {
       onLast: () => null
     });
   }
-
   filterRoutes(routes) {
     return routes;
   }
-
-  async emitRouteHook(eventName, input) {
-    input.context = clone(input.context);
-    return this.runner[eventName](input, {
-      onLast: noop
-    });
-  }
-
   async setupBeforeProdMiddleware() {
     const {
       conf,
@@ -309,20 +315,16 @@ export class ModernServer {
       this.addHandler(mid);
     });
   }
-
   async handleAPI(context) {
     const {
       req,
       res
     } = context;
-
     if (!this.frameAPIHandler) {
       throw new Error('can not found api handler');
     }
-
     await this.frameAPIHandler(req, res);
   }
-
   async handleWeb(context, route) {
     return this.routeRenderHandler({
       ctx: context,
@@ -330,272 +332,198 @@ export class ModernServer {
       runner: this.runner
     });
   }
-
   async proxy() {
     return null;
-  } // warmup ssr function
-
+  }
 
+  // warmup ssr function
   warmupSSRBundle() {
     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
-
+      const filepath = path.join(distDir, bundle);
+      // if error, just throw and let process die
       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
 
+    // match routes in the route spec
     const matched = this.router.match(context.path);
-
     if (!matched) {
       this.render404(context);
       return;
     }
 
-    if (res.headersSent) {
+    // route is api service
+    let route = matched.generate(context.url);
+    if (route.isApi) {
+      await this.handleAPI(context);
       return;
     }
+    const afterMatchContext = createAfterMatchContext(context, route.entryName);
 
-    const routeAPI = createRouteAPI(matched, this.router, context.url);
-    await this.emitRouteHook('afterMatch', {
-      context,
-      routeAPI
-    });
-
+    // only full mode run server hook
+    if (this.runMode === RUN_MODE.FULL) {
+      await this.runner.afterMatch(afterMatchContext, {
+        onLast: 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);
-    } // frameWebHandler has process request
-
+      res.locals = res.locals || {};
+      const middlewareContext = createMiddlewareContext(context);
+      await this.frameWebHandler(middlewareContext);
+      res.locals = _objectSpread(_objectSpread({}, res.locals), middlewareContext.response.locals);
+    }
 
+    // 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);
         }
       });
     }
-
-    if (route.entryName) {
-      await this.emitRouteHook('beforeRender', {
-        context
-      });
-    }
-
-    const file = await this.handleWeb(context, route);
-
-    if (!file) {
+    const renderResult = await this.handleWeb(context, route);
+    if (!renderResult) {
       this.render404(context);
       return;
     }
 
-    if (file.redirect) {
-      res.statusCode = file.statusCode;
-      res.setHeader('Location', file.content);
-      res.end();
+    // React Router navigation
+    if (renderResult.redirect) {
+      this.redirect(res, renderResult.content, renderResult.statusCode);
       return;
     }
-
     if (this.isSend(res)) {
       return;
     }
-
-    let response = file.content;
-
+    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>` : undefined
+      })).pipe(res);
+      return;
+    }
+    let response = renderResult.content;
     if (route.entryName) {
-      const templateAPI = createTemplateAPI(file.content.toString());
-      await this.emitRouteHook('afterRender', {
-        context,
-        templateAPI
-      });
-
+      const afterRenderContext = createAfterRenderContext(context, response.toString());
+
+      // only full mode run server hook
+      // FIXME: how to run server hook in streaming
+      if (this.runMode === RUN_MODE.FULL) {
+        await this.runner.afterRender(afterRenderContext, {
+          onLast: noop
+        });
+      }
       if (this.isSend(res)) {
         return;
       }
 
-      await this.injectMicroFE(context, templateAPI); // It will inject _SERVER_DATA twice, when SSG mode.
+      // 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);
   }
-
   isSend(res) {
     if (res.headersSent) {
       return true;
     }
-
     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 handlers and create the final handler
   compose() {
     const {
       handlers
     } = this;
-
     if (!Array.isArray(handlers)) {
       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!');
       }
     }
-
     this._handler = (context, next) => {
       let i = 0;
-
       const dispatch = error => {
         if (error) {
           return this.onError(context, error);
         }
-
         const handler = handlers[i++];
-
         if (!handler) {
           return next();
         }
-
         return handler(context, dispatch).catch(onError);
       };
-
       const onError = err => {
         this.onError(context, err);
       };
-
       return dispatch();
     };
   }
-
-  requestHandler(req, res, next = () => {// empty
+  requestHandler(req, res, next = () => {
+    // empty
   }) {
     res.statusCode = 200;
     req.logger = this.logger;
     req.metrics = this.metrics;
     let context;
-
     try {
       context = this.createContext(req, res);
     } catch (e) {
@@ -604,19 +532,21 @@ export class ModernServer {
       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
@@ -625,14 +555,15 @@ export class ModernServer {
     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
+    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
-
+      } = route;
+      // check entryName, avoid matched '/' route
       if (entryName === status.toString() || entryName === '_error') {
         try {
           const file = await this.routeRenderHandler({
@@ -640,19 +571,17 @@ export class ModernServer {
             ctx: context,
             runner: this.runner
           });
-
           if (file) {
             context.res.end(file.content);
             return;
           }
-        } catch (e) {// just catch error when the rendering error occurred in the custom error page.
+        } 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));
   }
-
 }
 /* eslint-enable max-lines */