@modern-js/prod-server 2.31.2 → 2.32.1

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @modern-js/prod-server
 
+## 2.32.1
+
+### Patch Changes
+
+- @modern-js/server-core@2.32.1
+- @modern-js/utils@2.32.1
+- @modern-js/plugin@2.32.1
+
+## 2.32.0
+
+### Minor Changes
+
+- 2447d64: feat: support ssr resources preload
+  feat: 支持 ssr 资源预加载
+
+### Patch Changes
+
+- e6c7d33: fix about server timing not use metaName at some case
+- 6076166: fix: packaging errors found by publint
+
+  fix: 修复 publint 检测到的 packaging 问题
+
+- 5f7c714: fix: WebSocket upgrade handler cause HMR connection issue
+  fix: WebSocket upgrade handler 导致 HMR 连接错误
+- 6d73519: fix: update server reportTimings name
+  fix: 更新 server reportTimings 名称
+- 79658a0: fix: collects ServerReportTiming Names, and then reports it only when cost != 0
+  fix: 收集 ServerReportTiming Names, 然后只有在 cost !=0 时才报告它
+- Updated dependencies [e5a3fb4]
+- Updated dependencies [6076166]
+- Updated dependencies [a030aff]
+- Updated dependencies [3c91100]
+- Updated dependencies [2447d64]
+- Updated dependencies [5255eba]
+  - @modern-js/utils@2.32.0
+  - @modern-js/plugin@2.32.0
+  - @modern-js/server-core@2.32.0
+
 ## 2.31.2
 
 ### Patch Changes

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Modern.js
+Copyright (c) 2021-present Modern.js
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/cjs/constants.js

@@ -13,6 +13,9 @@ _export(exports, {
   ApiServerMode: function() {
     return ApiServerMode;
   },
+  ServerReportTimings: function() {
+    return ServerReportTimings;
+  },
   AGGRED_DIR: function() {
     return AGGRED_DIR;
   },
@@ -54,3 +57,10 @@ const RUN_MODE = {
   FULL: "full",
   TYPE: "type"
 };
+var ServerReportTimings;
+(function(ServerReportTimings2) {
+  ServerReportTimings2["SERVER_HANDLE_REQUEST"] = "server-handle-request";
+  ServerReportTimings2["SERVER_MIDDLEWARE"] = "server-middleware";
+  ServerReportTimings2["SERVER_HOOK_AFTER_RENDER"] = "server-hook-after-render";
+  ServerReportTimings2["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
+})(ServerReportTimings || (ServerReportTimings = {}));

package/dist/cjs/libs/context/context.js

@@ -38,7 +38,12 @@ class ModernServerContext {
   bind() {
     const { req, res } = this;
     req.get = (key) => this.getReqHeader(key);
-    res.set = (key, value) => this.res.setHeader(key, value);
+    res.set = (key, value) => {
+      if (!res.headersSent) {
+        res.setHeader(key, value);
+      }
+      return res;
+    };
     res.send = (body) => {
       this.send(body);
     };
@@ -178,7 +183,7 @@ class ModernServerContext {
     this.req = req;
     this.res = res;
     this.options = options || {};
-    this.serverTiming = new _serverTiming.ServerTiming(res, (0, _utils.cutNameByHyphen)(((_options = options) === null || _options === void 0 ? void 0 : _options.metaName) || "modern-js"));
     this.bind();
+    this.serverTiming = new _serverTiming.ServerTiming(this.res, (0, _utils.cutNameByHyphen)(((_options = options) === null || _options === void 0 ? void 0 : _options.metaName) || "modern-js"));
   }
 }

package/dist/cjs/libs/preload/flushServerHeader.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  transformToRegExp: function() {
+    return transformToRegExp;
+  },
+  shouldFlushServerHeader: function() {
+    return shouldFlushServerHeader;
+  },
+  flushServerHeader: function() {
+    return flushServerHeader;
+  }
+});
+const _parseLinks = require("./parseLinks");
+const _transformLinks2String = require("./transformLinks2String");
+function transformToRegExp(input) {
+  if (typeof input === "string") {
+    return new RegExp(input);
+  }
+  return input;
+}
+function shouldFlushServerHeader(serverConf, userAgent, disablePreload) {
+  const { ssr: ssrConf } = serverConf || {};
+  if (disablePreload) {
+    return false;
+  }
+  if (typeof ssrConf === "object" && ssrConf.preload) {
+    if (typeof ssrConf.preload === "object") {
+      const { userAgentFilter } = ssrConf.preload;
+      if (userAgentFilter && userAgent) {
+        return !transformToRegExp(userAgentFilter).test(userAgent);
+      }
+      return true;
+    }
+    return true;
+  }
+  return false;
+}
+async function flushServerHeader({ serverConf, ctx, distDir, template, headers }) {
+  const { ssr: ssrConf } = serverConf || {};
+  if (typeof ssrConf !== "object") {
+    return;
+  }
+  const { res } = ctx;
+  const links = await (0, _parseLinks.parseLinks)({
+    template,
+    distDir,
+    pathname: ctx.path
+  });
+  const link = (0, _transformLinks2String.transformLinks2String)(links, ssrConf.preload);
+  res.set("link", link);
+  for (const key in headers || {}) {
+    var _headers;
+    const value = (_headers = headers) === null || _headers === void 0 ? void 0 : _headers[key];
+    value && res.set(key, value);
+  }
+  res.flushHeaders();
+}

package/dist/cjs/libs/preload/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("./parseLinks"), exports);
+_export_star._(require("./flushServerHeader"), exports);

package/dist/cjs/libs/preload/parseLinks.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "parseLinks", {
+  enumerable: true,
+  get: function() {
+    return parseLinks;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
+const _utils = require("@modern-js/utils");
+const _nodehtmlparser = require("node-html-parser");
+const _remixrouter = require("@modern-js/utils/runtime/remix-router");
+const _runtimenode = require("@modern-js/utils/runtime-node");
+async function parseLinks({ pathname, distDir, template }) {
+  const links = await parseLinksFromRoutes(pathname, distDir);
+  return links.length > 0 ? links : parseLinksFromHtml(template);
+}
+function parseLinksFromHtml(html) {
+  const root = (0, _nodehtmlparser.parse)(html);
+  const scripts = root.querySelectorAll("script").filter((elem) => Boolean(elem.getAttribute("src")));
+  const css = root.querySelectorAll("link").filter((elem) => {
+    const href = elem.getAttribute("href");
+    const rel = elem.getAttribute("rel");
+    return href && rel === "stylesheet";
+  });
+  const images = root.querySelectorAll("img").filter((elem) => Boolean(elem.getAttribute("src")));
+  return scripts.map((elem) => {
+    const src = elem.getAttribute("src");
+    return {
+      uri: src,
+      as: "script"
+    };
+  }).concat(css.map((elem) => {
+    const href = elem.getAttribute("href");
+    return {
+      uri: href,
+      as: "style"
+    };
+  })).concat(images.map((elem) => {
+    const src = elem.getAttribute("src");
+    return {
+      uri: src,
+      as: "image"
+    };
+  }));
+}
+async function parseLinksFromRoutes(pathname, distDir) {
+  const noopLinks = [];
+  const nestedRoutesSpec = _path.default.join(distDir, _utils.NESTED_ROUTE_SPEC_FILE);
+  const routesJsonPath = _path.default.join(distDir, _utils.ROUTE_SPEC_FILE);
+  const routeManifestPath = _path.default.join(distDir, _utils.ROUTE_MANIFEST_FILE);
+  if (!_utils.fs.existsSync(nestedRoutesSpec) || !_utils.fs.existsSync(routesJsonPath) || !_utils.fs.existsSync(routeManifestPath)) {
+    return noopLinks;
+  }
+  const routesJson = await Promise.resolve(routesJsonPath).then((p) => /* @__PURE__ */ _interop_require_wildcard._(require(p)));
+  const serverRoutes = routesJson.routes;
+  const entry = (0, _runtimenode.matchEntry)(pathname, serverRoutes);
+  if (entry) {
+    var _routeAssets_entryName, _matches, _assets_filter, _assets, _assets_filter1, _assets1;
+    const routes = await Promise.resolve(nestedRoutesSpec).then((p) => /* @__PURE__ */ _interop_require_wildcard._(require(p)));
+    const { entryName } = entry;
+    if (!entryName) {
+      return noopLinks;
+    }
+    const entryRoutes = routes[entryName];
+    if (!entryRoutes) {
+      return noopLinks;
+    }
+    const routesManifest = await Promise.resolve(routeManifestPath).then((p) => /* @__PURE__ */ _interop_require_wildcard._(require(p)));
+    const { routeAssets } = routesManifest;
+    const matches = (0, _remixrouter.matchRoutes)(entryRoutes, pathname, entry.urlPath);
+    const entryAssets = (_routeAssets_entryName = routeAssets[entryName]) === null || _routeAssets_entryName === void 0 ? void 0 : _routeAssets_entryName.assets;
+    const assets = (_matches = matches) === null || _matches === void 0 ? void 0 : _matches.reduce((acc, match) => {
+      const routeId = match.route.id;
+      if (routeId) {
+        var _matchedManifest;
+        const matchedManifest = routeAssets[routeId];
+        const assets2 = (_matchedManifest = matchedManifest) === null || _matchedManifest === void 0 ? void 0 : _matchedManifest.assets;
+        if (Array.isArray(assets2)) {
+          acc.push(...assets2);
+        }
+      }
+      return acc;
+    }, []).concat(entryAssets || []);
+    const cssLinks = (_assets = assets) === null || _assets === void 0 ? void 0 : (_assets_filter = _assets.filter((asset) => asset.endsWith(".css"))) === null || _assets_filter === void 0 ? void 0 : _assets_filter.map((uri) => ({
+      uri,
+      as: "style"
+    }));
+    const scriptLinks = (_assets1 = assets) === null || _assets1 === void 0 ? void 0 : (_assets_filter1 = _assets1.filter((asset) => asset.endsWith(".js"))) === null || _assets_filter1 === void 0 ? void 0 : _assets_filter1.map((uri) => ({
+      uri,
+      as: "script"
+    }));
+    return (cssLinks || []).concat(scriptLinks || []);
+  }
+  return noopLinks;
+}

package/dist/cjs/libs/preload/transformLinks2String.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "transformLinks2String", {
+  enumerable: true,
+  get: function() {
+    return transformLinks2String;
+  }
+});
+const _flushServerHeader = require("./flushServerHeader");
+function transformLinks2String(links, preload) {
+  if (typeof preload === "boolean") {
+    return links.map(({ uri, as }) => as ? `<${uri}>; rel=preload; as=${as}` : `<${uri}>; rel=preload`).join(", ");
+  }
+  const { include, exclude, attributes } = preload;
+  const resolveLinks = addAttributes(removeExclude(addInclude(links, include), exclude), attributes);
+  return resolveLinks.join(", ");
+  function addInclude(links2, include2) {
+    var _include;
+    const images = [
+      "gif",
+      "jpg",
+      "jpeg",
+      "png",
+      "webp",
+      "bmp",
+      "tiff",
+      "anpg",
+      "ico"
+    ];
+    const videos = [
+      "mp4",
+      "webm",
+      "ogm",
+      "ogv",
+      "ogg"
+    ];
+    const fonts = [
+      "woff",
+      "woff2",
+      "eot",
+      "ttf",
+      "otf"
+    ];
+    const includes = ((_include = include2) === null || _include === void 0 ? void 0 : _include.map((item) => {
+      if (typeof item === "string") {
+        const type = (() => {
+          if (item.endsWith(".js")) {
+            return "script";
+          }
+          if (item.endsWith(".css")) {
+            return "style";
+          }
+          if (images.some((image) => item.endsWith(`.${image}`))) {
+            return "image";
+          }
+          if (videos.some((video) => item.endsWith(`.${video}`))) {
+            return "video";
+          }
+          if (fonts.some((font) => item.endsWith(`.${font}`))) {
+            return "font";
+          }
+        })();
+        return {
+          uri: item,
+          as: type
+        };
+      }
+      return {
+        uri: item.url,
+        as: item.type
+      };
+    })) || [];
+    return links2.concat(includes);
+  }
+  function removeExclude(links2, exclude2) {
+    return exclude2 ? links2.filter(({ uri }) => !(0, _flushServerHeader.transformToRegExp)(exclude2).test(uri)) : links2;
+  }
+  function addAttributes(links2, attributes2) {
+    const parseAttributes = (_attributes) => {
+      return Object.entries(_attributes || {}).reduce((results, [key, value]) => {
+        if (typeof value === "boolean") {
+          value && results.push(`; ${key}`);
+          return results;
+        }
+        results.push(`; ${key}=${value}`);
+        return results;
+      }, []).join("");
+    };
+    return links2.map(({ uri, as }) => {
+      if (as) {
+        const attributesStr = (() => {
+          const { style, script, image, font } = attributes2 || {};
+          switch (as) {
+            case "script":
+              return parseAttributes(script);
+            case "style":
+              return parseAttributes(style);
+            case "image":
+              return parseAttributes(image);
+            case "font":
+              return parseAttributes(font);
+            default:
+              return "";
+          }
+        })();
+        return `<${uri}>; rel=preload; as=${as}${attributesStr}`;
+      }
+      return `<${uri}>; rel=preload`;
+    });
+  }
+}

package/dist/cjs/libs/proxy.js

@@ -17,55 +17,49 @@ _export(exports, {
     return createProxyHandler;
   }
 });
-const _httpproxymiddleware = require("http-proxy-middleware");
+const _httpproxymiddleware = require("http-proxy-middleware/dist/http-proxy-middleware");
 const _utils = require("../utils");
 function formatProxyOptions(proxyOptions) {
-  const formattedProxy = [];
-  if (!Array.isArray(proxyOptions)) {
-    if ("target" in proxyOptions) {
-      formattedProxy.push(proxyOptions);
-    } else {
-      Array.prototype.push.apply(formattedProxy, Object.keys(proxyOptions).reduce((total, source) => {
-        const option = proxyOptions[source];
-        total.push({
-          context: source,
-          changeOrigin: true,
-          logLevel: "warn",
-          ...typeof option === "string" ? {
-            target: option
-          } : option
-        });
-        return total;
-      }, []));
-    }
+  const ret = [];
+  if (Array.isArray(proxyOptions)) {
+    ret.push(...proxyOptions);
+  } else if ("target" in proxyOptions) {
+    ret.push(proxyOptions);
   } else {
-    formattedProxy.push(...proxyOptions);
-  }
-  return formattedProxy;
-}
-const createProxyHandler = (proxyOptions) => {
-  (0, _utils.debug)("createProxyHandler", proxyOptions);
-  const middlewares = [];
-  const handlers = [];
-  const handleUpgrade = (req, socket, head) => {
-    for (const middleware of middlewares) {
-      if (typeof middleware.upgrade === "function") {
-        middleware.upgrade(req, socket, head);
+    for (const [context, options] of Object.entries(proxyOptions)) {
+      const opts = {
+        context,
+        changeOrigin: true,
+        logLevel: "warn"
+      };
+      if (typeof options === "string") {
+        opts.target = options;
+      } else {
+        Object.assign(opts, options);
       }
+      ret.push(opts);
     }
+  }
+  const handleError = (err, _req, _res, _target) => {
+    console.error(err);
   };
-  if (!proxyOptions) {
-    return {
-      handlers,
-      handleUpgrade
-    };
+  for (const opts of ret) {
+    var _opts;
+    var _onError;
+    (_onError = (_opts = opts).onError) !== null && _onError !== void 0 ? _onError : _opts.onError = handleError;
   }
+  return ret;
+}
+const createProxyHandler = (proxyOptions) => {
+  (0, _utils.debug)("createProxyHandler", proxyOptions);
   const formattedOptionsList = formatProxyOptions(proxyOptions);
-  for (const options of formattedOptionsList) {
-    const middleware = (0, _httpproxymiddleware.createProxyMiddleware)(options.context, options);
+  const proxies = [];
+  const handlers = [];
+  for (const opts of formattedOptionsList) {
+    const proxy = new _httpproxymiddleware.HttpProxyMiddleware(opts.context, opts);
     const handler = async (ctx, next) => {
       const { req, res } = ctx;
-      const bypassUrl = typeof options.bypass === "function" ? options.bypass(req, res, options) : null;
+      const bypassUrl = typeof opts.bypass === "function" ? opts.bypass(req, res, opts) : null;
       if (typeof bypassUrl === "boolean") {
         ctx.status = 404;
         next();
@@ -73,12 +67,21 @@ const createProxyHandler = (proxyOptions) => {
         ctx.url = bypassUrl;
         next();
       } else {
-        middleware(req, res, next);
+        proxy.middleware(req, res, next);
       }
     };
-    middlewares.push(middleware);
+    proxies.push(proxy);
     handlers.push(handler);
   }
+  const handleUpgrade = (server) => {
+    for (const proxy of proxies) {
+      const raw = proxy;
+      if (raw.proxyOptions.ws === true && !raw.wsInternalSubscribed) {
+        server.on("upgrade", raw.handleUpgrade);
+        raw.wsInternalSubscribed = true;
+      }
+    }
+  };
   return {
     handlers,
     handleUpgrade

package/dist/cjs/libs/render/index.js

@@ -13,11 +13,12 @@ const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildc
 const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
 const _utils = require("@modern-js/utils");
 const _constants = require("../../constants");
+const _preload = require("../preload");
 const _static = require("./static");
 const _reader = require("./reader");
 const _ssr = /* @__PURE__ */ _interop_require_wildcard._(require("./ssr"));
 const _utils1 = require("./utils");
-const createRenderHandler = ({ distDir, staticGenerate, forceCSR, nonce, ssrRender, metaName = "modern-js" }) => async function render({ ctx, route, runner }) {
+const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, ssrRender, metaName = "modern-js" }) => async function render({ ctx, route, runner }) {
   if (ctx.resHasHandled()) {
     return null;
   }
@@ -35,6 +36,19 @@ const createRenderHandler = ({ distDir, staticGenerate, forceCSR, nonce, ssrRend
   const useCSR = forceCSR && (ctx.query.csr || ctx.headers[`x-${(0, _utils.cutNameByHyphen)(metaName)}-ssr-fallback`]);
   if (route.isSSR && !useCSR) {
     try {
+      const userAgent = ctx.getReqHeader("User-Agent");
+      const disablePreload = Boolean(ctx.headers[`x-${(0, _utils.cutNameByHyphen)(metaName)}-disable-preload`]);
+      if ((0, _preload.shouldFlushServerHeader)(conf.server, userAgent, disablePreload)) {
+        (0, _preload.flushServerHeader)({
+          serverConf: conf.server,
+          ctx,
+          distDir,
+          template: content.toString(),
+          headers: {
+            "Content-Type": _utils.mime.contentType(_path.default.extname(templatePath))
+          }
+        });
+      }
       const ssrRenderOptions = {
         distDir,
         entryName: route.entryName,
@@ -56,7 +70,7 @@ const createRenderHandler = ({ distDir, staticGenerate, forceCSR, nonce, ssrRend
       return result;
     } catch (err) {
       ctx.error(_constants.ERROR_DIGEST.ERENDER, err.stack || err.message);
-      ctx.res.setHeader("x-modern-ssr-fallback", "1");
+      ctx.res.set("x-modern-ssr-fallback", "1");
     }
   }
   return {

package/dist/cjs/libs/serverTiming.js

@@ -15,7 +15,7 @@ class ServerTiming {
     const _name = `bd-${this.meta}-${name}`;
     const serverTiming = this.res.getHeader(SERVER_TIMING) || this.res.getHeader(SERVER_TIMING.toLocaleLowerCase());
     const value = `${_name};${desc ? `decs="${desc}";` : ""} dur=${dur}`;
-    this.res.setHeader(SERVER_TIMING, serverTiming ? `${serverTiming}, ${value}` : value);
+    this.res.set(SERVER_TIMING, serverTiming ? `${serverTiming}, ${value}` : value);
     return this;
   }
   constructor(res, meta) {

package/dist/cjs/server/modernServer.js

@@ -28,17 +28,19 @@ const SERVER_DIR = "./server";
 class ModernServer {
   // server prepare
   async onInit(runner, app) {
-    var _conf_bff, _app, _app1, _this_conf_output;
+    var _conf_bff, _app, _this_conf_output;
     this.runner = runner;
     const { distDir, conf } = this;
     this.initReader();
     (0, _utils1.debug)("final server conf", this.conf);
-    const proxyHandlers = (0, _proxy.createProxyHandler)((_conf_bff = conf.bff) === null || _conf_bff === void 0 ? void 0 : _conf_bff.proxy);
-    (_app = app) === null || _app === void 0 ? void 0 : _app.on("upgrade", proxyHandlers.handleUpgrade);
-    proxyHandlers.handlers.forEach((handler) => {
-      this.addHandler(handler);
-    });
-    (_app1 = app) === null || _app1 === void 0 ? void 0 : _app1.on("close", () => {
+    if ((_conf_bff = conf.bff) === null || _conf_bff === void 0 ? void 0 : _conf_bff.proxy) {
+      const { handlers, handleUpgrade } = (0, _proxy.createProxyHandler)(conf.bff.proxy);
+      app && handleUpgrade(app);
+      handlers.forEach((handler) => {
+        this.addHandler(handler);
+      });
+    }
+    (_app = app) === null || _app === void 0 ? void 0 : _app.on("close", () => {
       this.reader.close();
     });
     const usageRoutes = this.filterRoutes(this.getRoutes());
@@ -62,6 +64,7 @@ class ModernServer {
       distDir,
       staticGenerate,
       forceCSR,
+      conf: this.conf,
       nonce: (_conf_security = conf.security) === null || _conf_security === void 0 ? void 0 : _conf_security.nonce,
       metaName
     });
@@ -256,7 +259,7 @@ class ModernServer {
     if (this.isSend(res)) {
       return null;
     }
-    res.setHeader("content-type", renderResult.contentType);
+    res.set("content-type", renderResult.contentType);
     return renderResult;
   }
   async proxy() {
@@ -291,7 +294,7 @@ class ModernServer {
     const end = (0, _time.time)();
     res.on("finish", () => {
       const cost = end();
-      reporter.reportTiming("server_handle_request", cost);
+      reporter.reportTiming(_constants.ServerReportTimings.SERVER_HANDLE_REQUEST, cost);
     });
     let route = matched.generate(context.url);
     if (route.isApi) {
@@ -306,7 +309,7 @@ class ModernServer {
           onLast: _utils1.noop
         });
         const cost = end2();
-        reporter.reportTiming("server_hook_after_render", cost);
+        cost && reporter.reportTiming(_constants.ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost);
       }
       if (this.isSend(res)) {
         return;
@@ -331,7 +334,7 @@ class ModernServer {
       const end2 = (0, _time.time)();
       await this.frameWebHandler(middlewareContext);
       const cost = end2();
-      reporter.reportTiming("server_middleware", cost);
+      cost && reporter.reportTiming(_constants.ServerReportTimings.SERVER_MIDDLEWARE, cost);
       res.locals = {
         ...res.locals,
         ...middlewareContext.response.locals
@@ -358,7 +361,7 @@ class ModernServer {
           onLast: _utils1.noop
         });
         const cost = end2();
-        reporter.reportTiming("server_hook_after_render", cost);
+        cost && reporter.reportTiming(_constants.ServerReportTimings.SERVER_HOOK_AFTER_RENDER, cost);
       }
       if (this.isSend(res)) {
         return;
@@ -368,7 +371,7 @@ class ModernServer {
     res.end(response);
   }
   isSend(res) {
-    if (res.headersSent) {
+    if (res.writableEnded) {
       return true;
     }
     if (res.getHeader("Location") && (0, _utils1.isRedirect)(res.statusCode)) {
@@ -420,7 +423,9 @@ class ModernServer {
     req.metrics = req.metrics || this.metrics;
     let context;
     try {
-      context = this.createContext(req, res);
+      context = this.createContext(req, res, {
+        metaName: this.metaName
+      });
     } catch (e) {
       this.logger.error(e);
       res.statusCode = 500;
@@ -434,7 +439,7 @@ class ModernServer {
     }
   }
   redirect(res, url, status = 302) {
-    res.setHeader("Location", url);
+    res.set("Location", url);
     res.statusCode = status;
     res.end();
   }
@@ -445,7 +450,7 @@ class ModernServer {
   async renderErrorPage(context, status) {
     const { res } = context;
     context.status = status;
-    res.setHeader("content-type", _utils.mime.contentType("html"));
+    res.set("content-type", _utils.mime.contentType("html"));
     const statusPage = `/${status}`;
     const customErrorPage = `/_error`;
     const matched = this.router.match(statusPage) || this.router.match(customErrorPage);

package/dist/esm/constants.js

@@ -26,3 +26,10 @@ export var RUN_MODE = {
   FULL: "full",
   TYPE: "type"
 };
+export var ServerReportTimings;
+(function(ServerReportTimings2) {
+  ServerReportTimings2["SERVER_HANDLE_REQUEST"] = "server-handle-request";
+  ServerReportTimings2["SERVER_MIDDLEWARE"] = "server-middleware";
+  ServerReportTimings2["SERVER_HOOK_AFTER_RENDER"] = "server-hook-after-render";
+  ServerReportTimings2["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
+})(ServerReportTimings || (ServerReportTimings = {}));