@modern-js/server-core 2.48.6 → 2.49.1-alpha.0

package/dist/esm-node/base/middlewares/renderHandler/dataHandler.js

@@ -0,0 +1,22 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+const dataHandler = async (request, { routeInfo, serverRoutes, reporter, logger, serverManifest }) => {
+  var _serverManifest_loaderBundles;
+  const serverLoaderModule = serverManifest === null || serverManifest === void 0 ? void 0 : (_serverManifest_loaderBundles = serverManifest.loaderBundles) === null || _serverManifest_loaderBundles === void 0 ? void 0 : _serverManifest_loaderBundles[routeInfo.entryName || MAIN_ENTRY_NAME];
+  if (!serverLoaderModule) {
+    return;
+  }
+  const { routes, handleRequest } = serverLoaderModule;
+  const response = await handleRequest({
+    request,
+    serverRoutes,
+    context: {
+      logger,
+      reporter
+    },
+    routes
+  });
+  return response;
+};
+export {
+  dataHandler
+};

package/dist/esm-node/base/middlewares/renderHandler/index.js

@@ -0,0 +1,73 @@
+import { checkIsProd, sortRoutes, getRuntimeEnv } from "../../utils";
+import { initReporter } from "../monitor";
+import { CustomServer } from "../customServer";
+import { createRender } from "./render";
+function createRenderHandler(render) {
+  return async (c, _) => {
+    var _c_env_node;
+    const logger = c.get("logger");
+    const reporter = c.get("reporter");
+    const templates = c.get("templates") || {};
+    const serverManifest = c.get("serverManifest") || {};
+    const locals = c.get("locals");
+    const metrics = c.get("metrics");
+    const request = c.req.raw;
+    const nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
+    const res = await render(request, {
+      logger,
+      nodeReq,
+      reporter,
+      templates,
+      metrics,
+      serverManifest,
+      locals
+    });
+    return res;
+  };
+}
+async function getRenderHandler(options) {
+  const { routes, pwd, config } = options;
+  if (routes && routes.length > 0) {
+    var _config_server, _options_config_security;
+    const ssrConfig = (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr;
+    const forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
+    const render = createRender({
+      routes,
+      pwd,
+      staticGenerate: options.staticGenerate,
+      metaName: options.metaName || "modern-js",
+      forceCSR,
+      nonce: (_options_config_security = options.config.security) === null || _options_config_security === void 0 ? void 0 : _options_config_security.nonce
+    });
+    return render;
+  }
+  return null;
+}
+async function bindRenderHandler(server, options) {
+  const { routes, pwd, disableCustomHook } = options;
+  const { runner } = server;
+  if (routes && routes.length > 0) {
+    const customServer = new CustomServer(runner, server, pwd);
+    if (getRuntimeEnv() === "node") {
+      const cacheModuleName = "./ssrCache";
+      const { ssrCache } = await import(cacheModuleName);
+      await ssrCache.loadCacheMod(checkIsProd() ? pwd : void 0);
+    }
+    const pageRoutes = routes.filter((route) => !route.isApi).sort(sortRoutes);
+    const render = await getRenderHandler(options);
+    for (const route of pageRoutes) {
+      const { urlPath: originUrlPath, entryName } = route;
+      const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
+      const customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
+      server.use(urlPath, initReporter(entryName));
+      !disableCustomHook && server.use(urlPath, customServerHookMiddleware);
+      const customServerMiddleware = customServer.getServerMiddleware();
+      server.use(urlPath, customServerMiddleware);
+      render && server.all(urlPath, createRenderHandler(render));
+    }
+  }
+}
+export {
+  bindRenderHandler,
+  getRenderHandler
+};

package/dist/esm-node/base/middlewares/renderHandler/render.js

@@ -0,0 +1,108 @@
+import { cutNameByHyphen } from "@modern-js/utils/universal";
+import { REPLACE_REG } from "../../../base/constants";
+import { createErrorHtml, sortRoutes, parseQuery, transformResponse, getPathname } from "../../utils";
+import { dataHandler } from "./dataHandler";
+import { ssrRender } from "./ssrRender";
+async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce }) {
+  return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals, metrics }) => {
+    const routeInfo = matchRoute(req, routes);
+    if (!routeInfo) {
+      return new Response(createErrorHtml(404), {
+        status: 404,
+        headers: {
+          "content-type": "text/html; charset=UTF-8"
+        }
+      });
+    }
+    const html = templates[routeInfo.entryName];
+    if (!html) {
+      return new Response(createErrorHtml(404), {
+        status: 404,
+        headers: {
+          "content-type": "text/html; charset=UTF-8"
+        }
+      });
+    }
+    const renderMode = getRenderMode(req, metaName || "modern-js", routeInfo.isSSR, forceCSR, nodeReq);
+    const renderOptions = {
+      pwd,
+      html,
+      routeInfo,
+      staticGenerate: staticGenerate || false,
+      metaName: metaName || "modern-js",
+      nonce,
+      logger,
+      nodeReq,
+      reporter,
+      serverRoutes: routes,
+      locals,
+      serverManifest,
+      metrics
+    };
+    switch (renderMode) {
+      case "data":
+        let response = await dataHandler(req, renderOptions);
+        if (!response) {
+          response = await renderHandler(req, renderOptions, "ssr");
+        }
+        return response;
+      case "ssr":
+      case "csr":
+        return renderHandler(req, renderOptions, renderMode);
+      default:
+        throw new Error(`Unknown render mode: ${renderMode}`);
+    }
+  };
+}
+async function renderHandler(request, options, mode) {
+  const serverData = {
+    router: {
+      baseUrl: options.routeInfo.urlPath,
+      params: {}
+    }
+  };
+  const response = await (mode === "ssr" ? ssrRender(request, options) : csrRender(options.html));
+  return transformResponse(response, injectServerData(serverData));
+}
+function matchRoute(req, routes) {
+  const sorted = routes.sort(sortRoutes);
+  for (const route of sorted) {
+    const pathname = getPathname(req);
+    if (pathname.startsWith(route.urlPath)) {
+      return route;
+    }
+  }
+  return void 0;
+}
+function getRenderMode(req, framework, isSSR, forceCSR, nodeReq) {
+  const query = parseQuery(req);
+  const fallbackHeader = `x-${cutNameByHyphen(framework)}-ssr-fallback`;
+  if (isSSR) {
+    if (query.__loader) {
+      return "data";
+    }
+    if (forceCSR && (query.csr || req.headers.get(fallbackHeader) || (nodeReq === null || nodeReq === void 0 ? void 0 : nodeReq.headers[fallbackHeader]))) {
+      return "csr";
+    }
+    return "ssr";
+  } else {
+    return "csr";
+  }
+}
+function csrRender(html) {
+  return new Response(html, {
+    status: 200,
+    headers: new Headers({
+      "content-type": "text/html; charset=UTF-8"
+    })
+  });
+}
+function injectServerData(serverData) {
+  const { head } = REPLACE_REG.before;
+  const searchValue = new RegExp(head);
+  const replcaeCb = (beforeHead) => `${beforeHead}<script type="application/json" id="__MODERN_SERVER_DATA__">${JSON.stringify(serverData)}</script>`;
+  return (template) => template.replace(searchValue, replcaeCb);
+}
+export {
+  createRender
+};

package/dist/esm-node/base/middlewares/renderHandler/serverTiming.js

@@ -0,0 +1,16 @@
+const SERVER_TIMING = "Server-Timing";
+class ServerTiming {
+  addServeTiming(name, dur, desc) {
+    const _name = `bd-${this.meta}-${name}`;
+    const value = `${_name};${desc ? `decs="${desc}";` : ""} dur=${dur}`;
+    this.headers.append(SERVER_TIMING, value);
+    return this;
+  }
+  constructor(headers, meta) {
+    this.meta = meta;
+    this.headers = headers;
+  }
+}
+export {
+  ServerTiming
+};

package/dist/esm-node/base/middlewares/renderHandler/ssrCache.js

@@ -0,0 +1,162 @@
+import { Readable } from "stream";
+import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
+import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
+import { createReadableStreamFromReadable } from "../../adapters/node/polyfills/stream";
+import { createTransformStream, getPathname } from "../../utils";
+class CacheManager {
+  async getCacheResult(req, cacheControl, render, ssrContext) {
+    const key = this.computedKey(req, cacheControl);
+    const value = await this.container.get(key);
+    const { maxAge, staleWhileRevalidate } = cacheControl;
+    const ttl = maxAge + staleWhileRevalidate;
+    if (value) {
+      const cache = JSON.parse(value);
+      const interval = Date.now() - cache.cursor;
+      if (interval <= maxAge) {
+        return {
+          data: cache.val,
+          status: "hit"
+        };
+      } else if (interval <= staleWhileRevalidate + maxAge) {
+        this.processCache(key, render, ssrContext, ttl);
+        return {
+          data: cache.val,
+          status: "stale"
+        };
+      } else {
+        return this.processCache(key, render, ssrContext, ttl, "expired");
+      }
+    } else {
+      return this.processCache(key, render, ssrContext, ttl, "miss");
+    }
+  }
+  async processCache(key, render, ssrContext, ttl, status) {
+    const renderResult = await render(ssrContext);
+    if (!renderResult) {
+      return {
+        data: ""
+      };
+    } else if (typeof renderResult === "string") {
+      const current = Date.now();
+      const cache = {
+        val: renderResult,
+        cursor: current
+      };
+      await this.container.set(key, JSON.stringify(cache), {
+        ttl
+      });
+      return {
+        data: renderResult,
+        status
+      };
+    } else {
+      const body = (
+        // TODO: remove node:stream, move it to ssr entry.
+        renderResult instanceof Readable ? createReadableStreamFromReadable(renderResult) : renderResult
+      );
+      let html = "";
+      const stream = createTransformStream((chunk) => {
+        html += chunk;
+        return chunk;
+      });
+      stream.readable.getReader().closed.then(() => {
+        const current = Date.now();
+        const cache = {
+          val: html,
+          cursor: current
+        };
+        this.container.set(key, JSON.stringify(cache), {
+          ttl
+        });
+      });
+      body.pipeThrough(stream);
+      return {
+        data: stream.readable,
+        status
+      };
+    }
+  }
+  computedKey(req, cacheControl) {
+    const pathname = getPathname(req);
+    const { customKey } = cacheControl;
+    const defaultKey = pathname.replace(/.+\/+$/, "");
+    if (customKey) {
+      if (typeof customKey === "string") {
+        return customKey;
+      } else {
+        return customKey(defaultKey);
+      }
+    } else {
+      return defaultKey;
+    }
+  }
+  constructor(container) {
+    this.container = container;
+  }
+}
+const CACHE_FILENAME = "cache";
+class ServerCache {
+  async loadCacheMod(pwd = process.cwd()) {
+    const path = await import("path").catch(() => {
+      return {};
+    });
+    const serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
+    const mod = requireExistModule(serverCacheFilepath, {
+      interop: false
+    });
+    this.cacheOption = mod === null || mod === void 0 ? void 0 : mod.cacheOption;
+    if (this.cacheOption && !(mod === null || mod === void 0 ? void 0 : mod.customContainer)) {
+      const cacheStorage = createMemoryStorage("__ssr__cache");
+      this.customContainer = cacheStorage;
+    } else {
+      this.customContainer = mod === null || mod === void 0 ? void 0 : mod.customContainer;
+    }
+    if (this.customContainer) {
+      this.cacheManger = new CacheManager(this.customContainer);
+    }
+  }
+  matchCacheControl(req) {
+    const { cacheOption } = this;
+    if (!cacheOption || !req) {
+      return void 0;
+    } else if (isCacheControl(cacheOption)) {
+      return cacheOption;
+    } else if (isCacheOptionProvider(cacheOption)) {
+      return cacheOption(req);
+    } else {
+      const url = req.url;
+      const options = Object.entries(cacheOption);
+      for (const [key, option] of options) {
+        if (key === "*" || new RegExp(key).test(url)) {
+          if (typeof option === "function") {
+            return option(req);
+          } else {
+            return option;
+          }
+        }
+      }
+      return void 0;
+    }
+    function isCacheOptionProvider(option) {
+      return typeof option === "function";
+    }
+    function isCacheControl(option) {
+      return typeof option === "object" && option !== null && "maxAge" in option;
+    }
+  }
+  async getCache(req, cacheControl, render, ssrContext) {
+    if (this.cacheManger) {
+      return this.cacheManger.getCacheResult(req, cacheControl, render, ssrContext);
+    } else {
+      const renderResult = await render(ssrContext);
+      return {
+        data: renderResult
+      };
+    }
+  }
+}
+const ssrCache = new ServerCache();
+export {
+  CacheManager,
+  ssrCache
+};

package/dist/esm-node/base/middlewares/renderHandler/ssrRender.js

@@ -0,0 +1,177 @@
+import { SERVER_RENDER_FUNCTION_NAME, MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import * as isbot from "isbot";
+import { getRuntimeEnv, parseHeaders, parseQuery, getHost, getPathname } from "../../utils";
+import { X_RENDER_CACHE } from "../../constants";
+import { ServerTiming } from "./serverTiming";
+const defaultReporter = {
+  init() {
+  },
+  reportError() {
+  },
+  reportTiming() {
+  },
+  reportInfo() {
+  },
+  reportWarn() {
+  }
+};
+async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, metrics }) {
+  var _serverManifest_renderBundles;
+  const { entryName } = routeInfo;
+  const loadableStats = serverManifest.loadableStats || {};
+  const routeManifest = serverManifest.routeManifest || {};
+  const host = getHost(request);
+  const isSpider = isbot.default(request.headers.get("user-agent"));
+  const responseProxy = new ResponseProxy();
+  const query = parseQuery(request);
+  const headers = parseHeaders(request);
+  if (nodeReq) {
+    for (const key in nodeReq.headers) {
+      if (!headers[key]) {
+        headers[key] = nodeReq.headers[key];
+      }
+    }
+  }
+  const ssrContext = {
+    request: {
+      baseUrl: routeInfo.urlPath,
+      params: {},
+      pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : getPathname(request),
+      host,
+      query,
+      url: nodeReq ? getHrefFromNodeReq(nodeReq) : request.url,
+      headers
+    },
+    response: {
+      setHeader(key, value) {
+        responseProxy.headers.set(key, value);
+      },
+      status(code) {
+        responseProxy.status = code;
+      },
+      locals: locals || {}
+    },
+    redirection: {},
+    template: html,
+    loadableStats,
+    routeManifest,
+    entryName,
+    staticGenerate,
+    logger,
+    metrics,
+    serverTiming: new ServerTiming(responseProxy.headers, metaName),
+    reporter: reporter || defaultReporter,
+    /** @deprecated node req */
+    req: nodeReq || request,
+    /** @deprecated node res  */
+    res: void 0,
+    isSpider,
+    nonce
+  };
+  const renderBundle = (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[entryName || MAIN_ENTRY_NAME];
+  if (!renderBundle) {
+    throw new Error(`Can't found renderBundle ${entryName || MAIN_ENTRY_NAME}`);
+  }
+  const runtimeEnv = getRuntimeEnv();
+  let ssrResult;
+  let cacheStatus;
+  const render = renderBundle[SERVER_RENDER_FUNCTION_NAME];
+  if (runtimeEnv === "node") {
+    const cacheModuleName = "./ssrCache";
+    const { ssrCache } = await import(cacheModuleName);
+    const incomingMessage = nodeReq ? nodeReq : new IncomingMessgeProxy(request);
+    const cacheControl = await ssrCache.matchCacheControl(incomingMessage);
+    if (cacheControl) {
+      const { data: data2, status } = await ssrCache.getCache(request, cacheControl, render, ssrContext);
+      ssrResult = data2;
+      cacheStatus = status;
+    } else {
+      ssrResult = await render(ssrContext);
+    }
+  } else {
+    ssrResult = await render(ssrContext);
+  }
+  const { redirection } = ssrContext;
+  if (cacheStatus) {
+    responseProxy.headers.set(X_RENDER_CACHE, cacheStatus);
+  }
+  if (redirection.url) {
+    const { headers: headers2 } = responseProxy;
+    headers2.set("Location", redirection.url);
+    return new Response(null, {
+      status: redirection.status || 302,
+      headers: {
+        Location: redirection.url
+      }
+    });
+  }
+  const { Readable } = await import("stream").catch((_) => ({
+    Readable: void 0
+  }));
+  const streamModule = "../../adapters/node/polyfills/stream";
+  const { createReadableStreamFromReadable } = runtimeEnv === "node" ? await import(streamModule).catch((_) => ({
+    createReadableStreamFromReadable: void 0
+  })) : {
+    createReadableStreamFromReadable: void 0
+  };
+  const data = Readable && ssrResult instanceof Readable ? (createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(ssrResult)) || "" : ssrResult;
+  if (typeof data !== "string") {
+    responseProxy.headers.set("transfer-encoding", "chunked");
+  }
+  return new Response(data, {
+    status: responseProxy.status,
+    headers: responseProxy.headers
+  });
+}
+class ResponseProxy {
+  constructor() {
+    this.headers = new Headers();
+    this.status = 200;
+    this.headers.set("content-type", "text/html; charset=UTF-8");
+  }
+}
+class IncomingMessgeProxy {
+  constructor(req) {
+    this.headers = {};
+    req.headers.forEach((value, key) => {
+      this.headers[key] = value;
+    });
+    this.method = req.method;
+    this.url = getPathname(req);
+  }
+}
+function getHrefFromNodeReq(nodeReq) {
+  function getProtocal() {
+    if (nodeReq.socket.encrypted) {
+      return "https";
+    }
+    const proto = nodeReq.headers["x-forwarded-proto"];
+    return proto ? proto.split(/\s*,\s*/, 1)[0] : "http";
+  }
+  function getHost2() {
+    let host = nodeReq.headers["x-forwarded-host"];
+    if (!host) {
+      host = nodeReq.headers.host;
+    }
+    host = host.split(/\s*,\s*/, 1)[0] || "undefined";
+    return host;
+  }
+  const href = `${getProtocal()}://${getHost2()}${nodeReq.url || ""}`;
+  return href;
+}
+function getPathnameFromNodeReq(nodeReq) {
+  const { url } = nodeReq;
+  if (!url) {
+    return "/";
+  }
+  const match = url.match(/\/[^?]*/);
+  let pathname = match ? match[0] : "/";
+  if (pathname !== "/" && pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  return pathname;
+}
+export {
+  getPathnameFromNodeReq,
+  ssrRender
+};