@modern-js/prod-server 2.31.2 → 2.32.0

package/dist/esm/server/modernServer.js

@@ -16,7 +16,7 @@ import { createErrorDocument, createMiddlewareCollecter, getStaticReg, mergeExte
 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 { AGGRED_DIR, ERROR_DIGEST, ERROR_PAGE_TEXT, RUN_MODE, ServerReportTimings } from "../constants";
 import { createAfterMatchContext, createAfterRenderContext, createMiddlewareContext } from "../libs/hook-api";
 var SERVER_DIR = "./server";
 export var ModernServer = /* @__PURE__ */ function() {
@@ -68,7 +68,7 @@ export var ModernServer = /* @__PURE__ */ function() {
         function onInit(runner, app) {
           var _this = this;
           return _async_to_generator(function() {
-            var _conf_bff, _app, _app1, _this_conf_output, distDir, conf, proxyHandlers, usageRoutes;
+            var _conf_bff, _app, _this_conf_output, distDir, conf, _createProxyHandler, handlers, handleUpgrade, usageRoutes;
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
@@ -76,12 +76,14 @@ export var ModernServer = /* @__PURE__ */ function() {
                   distDir = _this.distDir, conf = _this.conf;
                   _this.initReader();
                   debug("final server conf", _this.conf);
-                  proxyHandlers = 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(function(handler) {
-                    _this.addHandler(handler);
-                  });
-                  (_app1 = app) === null || _app1 === void 0 ? void 0 : _app1.on("close", function() {
+                  if ((_conf_bff = conf.bff) === null || _conf_bff === void 0 ? void 0 : _conf_bff.proxy) {
+                    _createProxyHandler = createProxyHandler(conf.bff.proxy), handlers = _createProxyHandler.handlers, handleUpgrade = _createProxyHandler.handleUpgrade;
+                    app && handleUpgrade(app);
+                    handlers.forEach(function(handler) {
+                      _this.addHandler(handler);
+                    });
+                  }
+                  (_app = app) === null || _app === void 0 ? void 0 : _app.on("close", function() {
                     _this.reader.close();
                   });
                   usageRoutes = _this.filterRoutes(_this.getRoutes());
@@ -130,6 +132,7 @@ export var ModernServer = /* @__PURE__ */ function() {
           distDir: distDir,
           staticGenerate: staticGenerate,
           forceCSR: forceCSR,
+          conf: this.conf,
           nonce: (_conf_security = conf.security) === null || _conf_security === void 0 ? void 0 : _conf_security.nonce,
           metaName: metaName
         });
@@ -613,7 +616,7 @@ export var ModernServer = /* @__PURE__ */ function() {
                     null
                   ];
                 }
-                res.setHeader("content-type", renderResult.contentType);
+                res.set("content-type", renderResult.contentType);
                 return [
                   2,
                   renderResult
@@ -690,7 +693,7 @@ export var ModernServer = /* @__PURE__ */ function() {
                   end = time();
                   res.on("finish", function() {
                     var cost3 = end();
-                    reporter.reportTiming("server_handle_request", cost3);
+                    reporter.reportTiming(ServerReportTimings.SERVER_HANDLE_REQUEST, cost3);
                   });
                   route = matched.generate(context.url);
                   if (!route.isApi)
@@ -729,7 +732,7 @@ export var ModernServer = /* @__PURE__ */ function() {
                 case 4:
                   _state.sent();
                   cost = end1();
-                  reporter.reportTiming("server_hook_after_render", cost);
+                  cost && reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost);
                   _state.label = 5;
                 case 5:
                   if (_this.isSend(res)) {
@@ -771,7 +774,7 @@ export var ModernServer = /* @__PURE__ */ function() {
                 case 7:
                   _state.sent();
                   cost1 = end2();
-                  reporter.reportTiming("server_middleware", cost1);
+                  cost1 && reporter.reportTiming(ServerReportTimings.SERVER_MIDDLEWARE, cost1);
                   res.locals = _object_spread({}, res.locals, middlewareContext.response.locals);
                   if (_this.isSend(res)) {
                     return [
@@ -820,7 +823,7 @@ export var ModernServer = /* @__PURE__ */ function() {
                 case 10:
                   _state.sent();
                   cost2 = end3();
-                  reporter.reportTiming("server_hook_after_render", cost2);
+                  cost2 && reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_RENDER, cost2);
                   _state.label = 11;
                 case 11:
                   if (_this.isSend(res)) {
@@ -844,7 +847,7 @@ export var ModernServer = /* @__PURE__ */ function() {
     {
       key: "isSend",
       value: function isSend(res) {
-        if (res.headersSent) {
+        if (res.writableEnded) {
           return true;
         }
         if (res.getHeader("Location") && isRedirect(res.statusCode)) {
@@ -923,7 +926,9 @@ export var ModernServer = /* @__PURE__ */ function() {
         req.metrics = req.metrics || this.metrics;
         var context;
         try {
-          context = this.createContext(req, res);
+          context = this.createContext(req, res, {
+            metaName: this.metaName
+          });
         } catch (e) {
           this.logger.error(e);
           res.statusCode = 500;
@@ -941,7 +946,7 @@ export var ModernServer = /* @__PURE__ */ function() {
       key: "redirect",
       value: function redirect(res, url) {
         var status = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 302;
-        res.setHeader("Location", url);
+        res.set("Location", url);
         res.statusCode = status;
         res.end();
       }
@@ -964,7 +969,7 @@ export var ModernServer = /* @__PURE__ */ function() {
               case 0:
                 res = context.res;
                 context.status = status;
-                res.setHeader("content-type", mime.contentType("html"));
+                res.set("content-type", mime.contentType("html"));
                 statusPage = "/".concat(status);
                 customErrorPage = "/_error";
                 matched = _this.router.match(statusPage) || _this.router.match(customErrorPage);

package/dist/esm-node/constants.js

@@ -26,3 +26,10 @@ export const 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 = {}));

package/dist/esm-node/libs/context/context.js

@@ -27,7 +27,12 @@ export 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);
     };
@@ -167,7 +172,7 @@ export class ModernServerContext {
     this.req = req;
     this.res = res;
     this.options = options || {};
-    this.serverTiming = new ServerTiming(res, cutNameByHyphen(((_options = options) === null || _options === void 0 ? void 0 : _options.metaName) || "modern-js"));
     this.bind();
+    this.serverTiming = new ServerTiming(this.res, cutNameByHyphen(((_options = options) === null || _options === void 0 ? void 0 : _options.metaName) || "modern-js"));
   }
 }

package/dist/esm-node/libs/preload/flushServerHeader.js

@@ -0,0 +1,45 @@
+import { parseLinks } from "./parseLinks";
+import { transformLinks2String } from "./transformLinks2String";
+export function transformToRegExp(input) {
+  if (typeof input === "string") {
+    return new RegExp(input);
+  }
+  return input;
+}
+export 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;
+}
+export async function flushServerHeader({ serverConf, ctx, distDir, template, headers }) {
+  const { ssr: ssrConf } = serverConf || {};
+  if (typeof ssrConf !== "object") {
+    return;
+  }
+  const { res } = ctx;
+  const links = await parseLinks({
+    template,
+    distDir,
+    pathname: ctx.path
+  });
+  const link = 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/esm-node/libs/preload/index.js

@@ -0,0 +1,2 @@
+export * from "./parseLinks";
+export * from "./flushServerHeader";

package/dist/esm-node/libs/preload/parseLinks.js

@@ -0,0 +1,88 @@
+import path from "path";
+import { NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, ROUTE_SPEC_FILE, fs } from "@modern-js/utils";
+import { parse as htmlParse } from "node-html-parser";
+import { matchRoutes } from "@modern-js/utils/runtime/remix-router";
+import { matchEntry } from "@modern-js/utils/runtime-node";
+export async function parseLinks({ pathname, distDir, template }) {
+  const links = await parseLinksFromRoutes(pathname, distDir);
+  return links.length > 0 ? links : parseLinksFromHtml(template);
+}
+function parseLinksFromHtml(html) {
+  const root = htmlParse(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.join(distDir, NESTED_ROUTE_SPEC_FILE);
+  const routesJsonPath = path.join(distDir, ROUTE_SPEC_FILE);
+  const routeManifestPath = path.join(distDir, ROUTE_MANIFEST_FILE);
+  if (!fs.existsSync(nestedRoutesSpec) || !fs.existsSync(routesJsonPath) || !fs.existsSync(routeManifestPath)) {
+    return noopLinks;
+  }
+  const routesJson = await import(routesJsonPath);
+  const serverRoutes = routesJson.routes;
+  const entry = matchEntry(pathname, serverRoutes);
+  if (entry) {
+    var _routeAssets_entryName, _matches, _assets_filter, _assets, _assets_filter1, _assets1;
+    const routes = await import(nestedRoutesSpec);
+    const { entryName } = entry;
+    if (!entryName) {
+      return noopLinks;
+    }
+    const entryRoutes = routes[entryName];
+    if (!entryRoutes) {
+      return noopLinks;
+    }
+    const routesManifest = await import(routeManifestPath);
+    const { routeAssets } = routesManifest;
+    const matches = 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/esm-node/libs/preload/transformLinks2String.js

@@ -0,0 +1,103 @@
+import { transformToRegExp } from "./flushServerHeader";
+export 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 }) => !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/esm-node/libs/proxy.js

@@ -1,52 +1,46 @@
-import { createProxyMiddleware } from "http-proxy-middleware";
+import { HttpProxyMiddleware } from "http-proxy-middleware/dist/http-proxy-middleware";
 import { debug } from "../utils";
 export 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;
-}
-export const createProxyHandler = (proxyOptions) => {
-  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;
+}
+export const createProxyHandler = (proxyOptions) => {
+  debug("createProxyHandler", proxyOptions);
   const formattedOptionsList = formatProxyOptions(proxyOptions);
-  for (const options of formattedOptionsList) {
-    const middleware = createProxyMiddleware(options.context, options);
+  const proxies = [];
+  const handlers = [];
+  for (const opts of formattedOptionsList) {
+    const proxy = new 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();
@@ -54,12 +48,21 @@ export 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/esm-node/libs/render/index.js

@@ -1,11 +1,12 @@
 import path from "path";
 import { cutNameByHyphen, mime } from "@modern-js/utils";
 import { ERROR_DIGEST } from "../../constants";
+import { flushServerHeader, shouldFlushServerHeader } from "../preload";
 import { handleDirectory } from "./static";
 import { readFile } from "./reader";
 import * as ssr from "./ssr";
 import { injectServerData } from "./utils";
-export const createRenderHandler = ({ distDir, staticGenerate, forceCSR, nonce, ssrRender, metaName = "modern-js" }) => async function render({ ctx, route, runner }) {
+export const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, ssrRender, metaName = "modern-js" }) => async function render({ ctx, route, runner }) {
   if (ctx.resHasHandled()) {
     return null;
   }
@@ -23,6 +24,19 @@ export const createRenderHandler = ({ distDir, staticGenerate, forceCSR, nonce,
   const useCSR = forceCSR && (ctx.query.csr || ctx.headers[`x-${cutNameByHyphen(metaName)}-ssr-fallback`]);
   if (route.isSSR && !useCSR) {
     try {
+      const userAgent = ctx.getReqHeader("User-Agent");
+      const disablePreload = Boolean(ctx.headers[`x-${cutNameByHyphen(metaName)}-disable-preload`]);
+      if (shouldFlushServerHeader(conf.server, userAgent, disablePreload)) {
+        flushServerHeader({
+          serverConf: conf.server,
+          ctx,
+          distDir,
+          template: content.toString(),
+          headers: {
+            "Content-Type": mime.contentType(path.extname(templatePath))
+          }
+        });
+      }
       const ssrRenderOptions = {
         distDir,
         entryName: route.entryName,
@@ -44,7 +58,7 @@ export const createRenderHandler = ({ distDir, staticGenerate, forceCSR, nonce,
       return result;
     } catch (err) {
       ctx.error(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/esm-node/libs/serverTiming.js

@@ -5,7 +5,7 @@ export 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) {