@modern-js/server-core 2.48.1 → 2.48.3-alpha.0

package/dist/cjs/base/middlewares/renderHandler/render.js

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var render_exports = {};
+__export(render_exports, {
+  createRender: () => createRender
+});
+module.exports = __toCommonJS(render_exports);
+var import_constants = require("../../../base/constants");
+var import_utils = require("../../utils");
+var import_dataHandler = require("./dataHandler");
+var import_ssrRender = require("./ssrRender");
+async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce }) {
+  return async (req, { logger, nodeReq, reporter, templates, serverManifest }) => {
+    const routeInfo = matchRoute(req, routes);
+    if (!routeInfo) {
+      return new Response((0, import_utils.createErrorHtml)(404), {
+        status: 404,
+        headers: {
+          "content-type": "text/html; charset=UTF-8"
+        }
+      });
+    }
+    const html = templates[routeInfo.entryName];
+    if (!html) {
+      throw new Error(`Can't found entry ${routeInfo.entryName} html `);
+    }
+    const renderMode = getRenderMode(req, metaName || "modern-js", routeInfo.isSSR, forceCSR);
+    const renderOptions = {
+      pwd,
+      html,
+      routeInfo,
+      staticGenerate: staticGenerate || false,
+      metaName: metaName || "modern-js",
+      nonce,
+      logger,
+      nodeReq,
+      reporter,
+      serverRoutes: routes,
+      serverManifest
+    };
+    switch (renderMode) {
+      case "data":
+        let response = await (0, import_dataHandler.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" ? (0, import_ssrRender.ssrRender)(request, options) : csrRender(options.html));
+  return (0, import_utils.transformResponse)(response, injectServerData(serverData));
+}
+function matchRoute(req, routes) {
+  const sorted = routes.sort(import_utils.sortRoutes);
+  for (const route of sorted) {
+    const pathname = (0, import_utils.getPathname)(req);
+    if (pathname.startsWith(route.urlPath)) {
+      return route;
+    }
+  }
+  return void 0;
+}
+function getRenderMode(req, framework, isSSR, forceCSR) {
+  const query = (0, import_utils.parseQuery)(req);
+  if (isSSR) {
+    if (query.__loader) {
+      return "data";
+    }
+    if (forceCSR && (query.csr || req.headers.get(`x-${(0, import_utils.cutNameByHyphen)(framework)}-ssr-fallback`))) {
+      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 } = import_constants.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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRender
+});

package/dist/cjs/base/middlewares/renderHandler/serverTiming.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serverTiming_exports = {};
+__export(serverTiming_exports, {
+  ServerTiming: () => ServerTiming
+});
+module.exports = __toCommonJS(serverTiming_exports);
+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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServerTiming
+});

package/dist/cjs/base/middlewares/renderHandler/ssrCache.js

@@ -0,0 +1,197 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ssrCache_exports = {};
+__export(ssrCache_exports, {
+  CacheManager: () => CacheManager,
+  ssrCache: () => ssrCache
+});
+module.exports = __toCommonJS(ssrCache_exports);
+var import_stream = require("stream");
+var import_utils = require("@modern-js/utils");
+var import_storer = require("@modern-js/runtime-utils/storer");
+var import_stream2 = require("../../adapters/node/polyfills/stream");
+var import_utils2 = require("../../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 import_stream.Readable ? (0, import_stream2.createReadableStreamFromReadable)(renderResult) : renderResult
+      );
+      let html = "";
+      const stream = (0, import_utils2.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 = (0, import_utils2.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 Promise.resolve().then(() => __toESM(require("path"))).catch(() => {
+      return {};
+    });
+    const serverCacheFilepath = path.resolve(pwd, import_utils.SERVER_DIR, CACHE_FILENAME);
+    const mod = (0, import_utils.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 = (0, import_storer.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();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheManager,
+  ssrCache
+});

package/dist/cjs/base/middlewares/renderHandler/ssrRender.js

@@ -0,0 +1,168 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ssrRender_exports = {};
+__export(ssrRender_exports, {
+  ssrRender: () => ssrRender
+});
+module.exports = __toCommonJS(ssrRender_exports);
+var import_constants = require("@modern-js/utils/universal/constants");
+var isbot = __toESM(require("isbot"));
+var import_utils = require("../../utils");
+var import_constants2 = require("../../constants");
+var import_serverTiming = require("./serverTiming");
+const defaultReporter = {
+  init() {
+  },
+  reportError() {
+  },
+  reportTiming() {
+  },
+  reportInfo() {
+  },
+  reportWarn() {
+  }
+};
+async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest }) {
+  var _serverManifest_renderBundles;
+  const { entryName } = routeInfo;
+  const loadableStats = serverManifest.loadableStats || {};
+  const routeManifest = serverManifest.routeManifest || {};
+  const host = (0, import_utils.getHost)(request);
+  const isSpider = isbot.default(request.headers.get("user-agent"));
+  const responseProxy = new ResponseProxy();
+  const query = (0, import_utils.parseQuery)(request);
+  const headers = (0, import_utils.parseHeaders)(request);
+  const ssrContext = {
+    request: {
+      baseUrl: routeInfo.urlPath,
+      params: {},
+      // eslint-disable-next-line node/no-unsupported-features/node-builtins, node/prefer-global/url
+      pathname: new URL(request.url).pathname,
+      host,
+      query,
+      url: request.url,
+      headers
+    },
+    response: {
+      setHeader(key, value) {
+        responseProxy.headers.set(key, value);
+      },
+      status(code) {
+        responseProxy.status = code;
+      }
+    },
+    redirection: {},
+    template: html,
+    loadableStats,
+    routeManifest,
+    entryName,
+    staticGenerate,
+    logger,
+    serverTiming: new import_serverTiming.ServerTiming(responseProxy.headers, metaName),
+    reporter: reporter || defaultReporter,
+    /** @deprecated node req */
+    req: nodeReq,
+    /** @deprecated node res  */
+    res: void 0,
+    isSpider,
+    nonce
+  };
+  const renderBundle = (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[entryName || import_constants.MAIN_ENTRY_NAME];
+  if (!renderBundle) {
+    throw new Error(`Can't found renderBundle ${entryName || import_constants.MAIN_ENTRY_NAME}`);
+  }
+  const runtimeEnv = (0, import_utils.getRuntimeEnv)();
+  let ssrResult;
+  let cacheStatus;
+  const render = renderBundle[import_constants.SERVER_RENDER_FUNCTION_NAME];
+  if (runtimeEnv === "node") {
+    const cacheModuleName = "./ssrCache";
+    const { ssrCache } = await Promise.resolve().then(() => __toESM(require(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(import_constants2.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 Promise.resolve().then(() => __toESM(require("stream"))).catch((_) => ({
+    Readable: void 0
+  }));
+  const streamModule = "../../adapters/node/polyfills/stream";
+  const { createReadableStreamFromReadable } = runtimeEnv === "node" ? await Promise.resolve().then(() => __toESM(require(streamModule))).catch((_) => ({
+    createReadableStreamFromReadable: void 0
+  })) : {
+    createReadableStreamFromReadable: void 0
+  };
+  const data = Readable && ssrResult instanceof Readable ? (createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(ssrResult)) || "" : ssrResult;
+  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 = new URL(req.url).pathname;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ssrRender
+});