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

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

@@ -15,18 +15,16 @@ 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 {
@@ -75,6 +73,8 @@ export class ModernServer {
 
     _defineProperty(this, "routeRenderHandler", void 0);
 
+    _defineProperty(this, "beforeRouteHandler", null);
+
     _defineProperty(this, "frameWebHandler", null);
 
     _defineProperty(this, "frameAPIHandler", null);
@@ -98,8 +98,7 @@ 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'}`;
+    this.runMode = runMode || RUN_MODE.FULL; // process.env.BUILD_TYPE = `${this.staticGenerate ? 'ssg' : 'ssr'}`;
   } // server prepare
 
 
@@ -132,7 +131,8 @@ export 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 = getStaticReg(this.conf.output || {});
@@ -145,7 +145,10 @@ export 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(faviconFallbackHandler);
+    this.addBeforeRouteHandler();
     this.addHandler(this.routeHandler.bind(this)); // compose middlewares to http handler
 
     this.compose();
@@ -155,6 +158,21 @@ export 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
   }) {
@@ -180,6 +198,26 @@ export class ModernServer {
     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);
   }
@@ -218,6 +256,19 @@ export class ModernServer {
   render404(context) {
     context.error(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
 
 
@@ -261,12 +312,13 @@ export class ModernServer {
       workDir,
       runner
     } = this;
-    return runner.prepareWebServer({
+    const handler = await runner.prepareWebServer({
       pwd: workDir,
       config: extension
     }, {
       onLast: () => null
     });
+    return handler;
   }
 
   async prepareAPIHandler(extension) {
@@ -292,13 +344,6 @@ export class ModernServer {
     return routes;
   }
 
-  async emitRouteHook(eventName, input) {
-    input.context = clone(input.context);
-    return this.runner[eventName](input, {
-      onLast: noop
-    });
-  }
-
   async setupBeforeProdMiddleware() {
     const {
       conf,
@@ -357,51 +402,70 @@ export 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 = createRouteAPI(matched, this.router, context.url);
-    await this.emitRouteHook('afterMatch', {
-      context,
-      routeAPI
-    });
+    const afterMatchContext = createAfterMatchContext(context, route.entryName); // 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);
+      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
 
 
@@ -419,23 +483,16 @@ export 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;
     }
 
@@ -443,29 +500,42 @@ export class ModernServer {
       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.isSend(res)) {
-        return;
+      if (this.runMode === RUN_MODE.FULL) {
+        await this.runner.afterRender(afterRenderContext, {
+          onLast: 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);
   }
 
@@ -480,72 +550,6 @@ export 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.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
 
 
@@ -612,6 +616,12 @@ export class ModernServer {
     }
   }
 
+  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);

package/dist/js/node/libs/hook-api/index.js

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMiddlewareContext = exports.createAfterRenderContext = exports.createAfterMatchContext = exports.base = void 0;
+
+var _cookie = _interopRequireDefault(require("cookie"));
+
+var _route = require("./route");
+
+var _template = require("./template");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 _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; }
+
+class Response {
+  constructor(res) {
+    _defineProperty(this, "cookies", void 0);
+
+    _defineProperty(this, "res", void 0);
+
+    _defineProperty(this, "_cookie", void 0);
+
+    this.res = res;
+    this._cookie = _cookie.default.parse(res.getHeader('set-cookie') || '');
+    this.cookies = {
+      get: this.getCookie.bind(this),
+      set: this.setCookie.bind(this),
+      delete: this.deleteCookie.bind(this),
+      clear: this.clearCookie.bind(this),
+      apply: this.applyCookie.bind(this)
+    };
+  }
+
+  get(key) {
+    return this.res.getHeader(key);
+  }
+
+  set(key, value) {
+    return this.res.setHeader(key, value);
+  }
+
+  status(code) {
+    this.res.statusCode = code;
+  }
+
+  getCookie(key) {
+    return this._cookie[key];
+  }
+
+  setCookie(key, value) {
+    this._cookie[key] = value;
+  }
+
+  deleteCookie(key) {
+    if (this._cookie[key]) {
+      delete this._cookie[key];
+    }
+  }
+
+  clearCookie() {
+    this._cookie = {};
+  }
+
+  applyCookie() {
+    const str = Object.entries(this._cookie).map(([key, value]) => {
+      return _cookie.default.serialize(key, value);
+    }).join('; ');
+
+    if (str) {
+      this.res.setHeader('set-cookie', str);
+    } else {
+      this.res.removeHeader('set-cookie');
+    }
+  }
+
+  raw(body, {
+    status,
+    headers
+  }) {
+    Object.entries(headers).forEach(([key, value]) => {
+      this.res.setHeader(key, value);
+    });
+
+    if (status) {
+      this.res.statusCode = status;
+    }
+
+    this.res.end(body);
+  }
+
+}
+
+class Request {
+  constructor(ctx) {
+    _defineProperty(this, "host", void 0);
+
+    _defineProperty(this, "pathname", void 0);
+
+    _defineProperty(this, "query", void 0);
+
+    _defineProperty(this, "headers", void 0);
+
+    _defineProperty(this, "cookie", void 0);
+
+    _defineProperty(this, "cookies", void 0);
+
+    _defineProperty(this, "_cookie", void 0);
+
+    this.host = ctx.host;
+    this.pathname = ctx.path;
+    this.query = ctx.query;
+    this.headers = ctx.headers;
+    this.cookie = ctx.headers.cookie || '';
+    this._cookie = _cookie.default.parse(this.cookie);
+    this.cookies = {
+      get: this.getCookie.bind(this)
+    };
+  }
+
+  getCookie(key) {
+    return this._cookie[key];
+  }
+
+}
+
+const base = context => {
+  const {
+    res
+  } = context;
+  return {
+    response: new Response(res),
+    request: new Request(context),
+    logger: context.logger,
+    metrics: context.metrics
+  };
+};
+
+exports.base = base;
+
+const createAfterMatchContext = (context, entryName) => {
+  const baseContext = base(context);
+  return _objectSpread(_objectSpread({}, baseContext), {}, {
+    router: new _route.RouteAPI(entryName)
+  });
+};
+
+exports.createAfterMatchContext = createAfterMatchContext;
+
+const createAfterRenderContext = (context, content) => {
+  const baseContext = base(context);
+  return _objectSpread(_objectSpread({}, baseContext), {}, {
+    template: new _template.TemplateAPI(content)
+  });
+};
+
+exports.createAfterRenderContext = createAfterRenderContext;
+
+const createMiddlewareContext = context => {
+  const baseContext = base(context);
+  return _objectSpread(_objectSpread({}, baseContext), {}, {
+    response: _objectSpread(_objectSpread({}, baseContext.response), {}, {
+      locals: context.res.locals || {}
+    }),
+    source: {
+      req: context.req,
+      res: context.res
+    }
+  });
+};
+
+exports.createMiddlewareContext = createMiddlewareContext;

package/dist/js/node/libs/hook-api/route.js

@@ -3,51 +3,36 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createRouteAPI = void 0;
+exports.RouteAPI = void 0;
 
 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; }
 
 class RouteAPI {
-  constructor(matched, router, url) {
-    _defineProperty(this, "router", void 0);
-
+  constructor(entryName) {
     _defineProperty(this, "current", void 0);
 
+    _defineProperty(this, "status", void 0);
+
     _defineProperty(this, "url", void 0);
 
-    this.current = matched;
-    this.router = router;
-    this.url = url;
+    this.current = entryName;
+    this.status = 200;
+    this.url = '';
   }
 
-  cur() {
-    return this.current.generate(this.url);
+  redirect(url, status = 302) {
+    this.url = url;
+    this.status = status;
   }
 
-  get(entryName) {
-    const {
-      router
-    } = this;
-    const matched = router.matchEntry(entryName);
-    return matched ? matched.generate(this.url) : null;
+  rewrite(entryName) {
+    this.current = entryName;
   }
 
   use(entryName) {
-    const {
-      router
-    } = this;
-    const matched = router.matchEntry(entryName);
-
-    if (matched) {
-      this.current = matched;
-      return true;
-    } else {
-      return false;
-    }
+    this.rewrite(entryName);
   }
 
 }
 
-const createRouteAPI = (matched, router, url) => new RouteAPI(matched, router, url);
-
-exports.createRouteAPI = createRouteAPI;
+exports.RouteAPI = RouteAPI;