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

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

@@ -1,15 +1,9 @@
 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';
@@ -29,8 +23,11 @@ const API_DIR = './api';
 const SERVER_DIR = './server';
 export class ModernServer {
   // appDirectory
+
   // product dist dir
+
   // work on src or dist
+
   constructor({
     pwd,
     config,
@@ -41,54 +38,30 @@ 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, "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.distDir = path.join(pwd, config.output.path || 'dist');
     this.workDir = this.distDir;
     this.conf = config;
     debug('server conf', this.conf);
@@ -98,44 +71,48 @@ export class ModernServer {
     this.presetRoutes = routes;
     this.proxyTarget = proxyTarget;
     this.staticGenerate = staticGenerate || false;
-    this.runMode = runMode || RUN_MODE.FULL; // 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();
-    await this.prepareBeforeRouteHandler(usageRoutes, distDir); // Only work when without setting `assetPrefix`.
-    // Setting `assetPrefix` means these resources should be uploaded to CDN.
+    await this.prepareBeforeRouteHandler(usageRoutes, distDir);
 
-    const staticPathRegExp = getStaticReg(this.conf.output || {});
+    // Only work when without setting `assetPrefix`.
+    // Setting `assetPrefix` means these resources should be uploaded to CDN.
+    const staticPathRegExp = getStaticReg(this.conf.output || {},
+    // FIXME:
+    this.conf.html);
     this.staticFileHandler = createStaticFileHandler([{
       path: staticPathRegExp,
       target: distDir
@@ -145,34 +122,33 @@ export class ModernServer {
       staticGenerate
     });
     await this.setupBeforeProdMiddleware();
-    this.addHandler(this.staticFileHandler); // execute after staticFileHandler, can rename to staticFallbackHandler if needed.
+    this.addHandler(this.staticFileHandler);
 
+    // execute after staticFileHandler, can rename to staticFallbackHandler if needed.
     this.addHandler(faviconFallbackHandler);
     this.addBeforeRouteHandler();
-    this.addHandler(this.routeHandler.bind(this)); // compose middlewares to http handler
+    this.addHandler(this.routeHandler.bind(this));
 
+    // compose middlewares to http handler
     this.compose();
-  } // server ready
-
-
-  onRepack(_) {// empty
   }
 
+  // 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
-
-
+      }
+      // eslint-disable-next-line consistent-return
       return next();
     });
   }
-
   onServerChange({
     filepath
   }) {
@@ -191,73 +167,63 @@ 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);
   }
-
   async prepareBeforeRouteHandler(specs, distDir) {
     const {
       runner
@@ -269,9 +235,9 @@ export class ModernServer {
       onLast: () => null
     });
     this.beforeRouteHandler = handler;
-  } // gather frame extension and get framework handler
-
+  }
 
+  // gather frame extension and get framework handler
   async prepareFrameHandler(options) {
     const {
       workDir,
@@ -280,33 +246,32 @@ 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,
@@ -320,7 +285,6 @@ export class ModernServer {
     });
     return handler;
   }
-
   async prepareAPIHandler(extension) {
     const {
       workDir,
@@ -339,11 +303,9 @@ export class ModernServer {
       onLast: () => null
     });
   }
-
   filterRoutes(routes) {
     return routes;
   }
-
   async setupBeforeProdMiddleware() {
     const {
       conf,
@@ -354,20 +316,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,
@@ -375,231 +333,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 {
       res
-    } = 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
-
+    }
 
+    // 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 afterMatchContext = createAfterMatchContext(context, route.entryName); // only full mode run server hook
-
+    // 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,
       url,
       status
-    } = afterMatchContext.router; // redirect to another url
-
+    } = afterMatchContext.router;
+    // redirect to another url
     if (url) {
       this.redirect(res, url, status);
       return;
-    } // rewrite to another entry
-
+    }
 
+    // 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
     });
-
     if (this.frameWebHandler) {
       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
-
+    }
 
+    // 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);
         }
       });
     }
-
     const renderResult = await this.handleWeb(context, route);
-
     if (!renderResult) {
       this.render404(context);
       return;
-    } // React Router navigation
-
+    }
 
+    // React Router navigation
     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>` : undefined
       })).pipe(res);
       return;
     }
-
     let response = renderResult.content;
-
     if (route.entryName) {
-      const afterRenderContext = createAfterRenderContext(context, response.toString()); // only full mode run server hook
-      // FIXME: how to run server hook in streaming
+      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;
-      } // 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,
-
-
       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)) {
       res.end();
       return true;
     }
-
     return false;
-  } // 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) {
@@ -608,25 +533,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
@@ -635,14 +556,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({
@@ -650,19 +572,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 */