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

package/dist/cjs/base/middlewares/monitor.js

@@ -0,0 +1,90 @@
+"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 monitor_exports = {};
+__export(monitor_exports, {
+  initReporter: () => initReporter,
+  injectLogger: () => injectLogger,
+  injectMetrics: () => injectMetrics,
+  injectReporter: () => injectReporter
+});
+module.exports = __toCommonJS(monitor_exports);
+var import_time = require("@modern-js/runtime-utils/time");
+var import_constants = require("../constants");
+const defaultReporter = {
+  init() {
+  },
+  reportError() {
+  },
+  reportTiming() {
+  },
+  reportInfo() {
+  },
+  reportWarn() {
+  }
+};
+function injectReporter() {
+  return async (c, next) => {
+    const reporter = c.get("reporter");
+    if (!reporter) {
+      c.set("reporter", defaultReporter);
+    }
+    await next();
+  };
+}
+function initReporter(entryName) {
+  return async (c, next) => {
+    const reporter = c.get("reporter");
+    if (!reporter) {
+      await next();
+      return;
+    }
+    await reporter.init({
+      entryName
+    });
+    const getCost = (0, import_time.time)();
+    await next();
+    const cost = getCost();
+    reporter.reportTiming(import_constants.ServerReportTimings.SERVER_HANDLE_REQUEST, cost);
+  };
+}
+function injectLogger(inputLogger) {
+  return async (c, next) => {
+    const logger = c.get("logger");
+    if (!logger && inputLogger) {
+      c.set("logger", inputLogger);
+    }
+    await next();
+  };
+}
+function injectMetrics(inputMetrics) {
+  return async (c, next) => {
+    const metrics = c.get("metrics");
+    if (!metrics) {
+      c.set("metrics", inputMetrics);
+    }
+    await next();
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initReporter,
+  injectLogger,
+  injectMetrics,
+  injectReporter
+});

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

@@ -0,0 +1,46 @@
+"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 dataHandler_exports = {};
+__export(dataHandler_exports, {
+  dataHandler: () => dataHandler
+});
+module.exports = __toCommonJS(dataHandler_exports);
+var import_constants = require("@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 || import_constants.MAIN_ENTRY_NAME];
+  if (!serverLoaderModule) {
+    return;
+  }
+  const { routes, handleRequest } = serverLoaderModule;
+  const response = await handleRequest({
+    request,
+    serverRoutes,
+    context: {
+      logger,
+      reporter
+    },
+    routes
+  });
+  return response;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dataHandler
+});

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

@@ -0,0 +1,108 @@
+"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 renderHandler_exports = {};
+__export(renderHandler_exports, {
+  bindRenderHandler: () => bindRenderHandler,
+  getRenderHandler: () => getRenderHandler
+});
+module.exports = __toCommonJS(renderHandler_exports);
+var import_utils = require("../../utils");
+var import_monitor = require("../monitor");
+var import_customServer = require("../customServer");
+var import_render = require("./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 = (0, import_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 import_customServer.CustomServer(runner, server, pwd);
+    if ((0, import_utils.getRuntimeEnv)() === "node") {
+      const cacheModuleName = "./ssrCache";
+      const { ssrCache } = await Promise.resolve().then(() => __toESM(require(cacheModuleName)));
+      await ssrCache.loadCacheMod((0, import_utils.checkIsProd)() ? pwd : void 0);
+    }
+    const pageRoutes = routes.filter((route) => !route.isApi).sort(import_utils.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, (0, import_monitor.initReporter)(entryName));
+      !disableCustomHook && server.use(urlPath, customServerHookMiddleware);
+      const customServerMiddleware = customServer.getServerMiddleware();
+      server.use(urlPath, customServerMiddleware);
+      render && server.all(urlPath, createRenderHandler(render));
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bindRenderHandler,
+  getRenderHandler
+});

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

@@ -0,0 +1,132 @@
+"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_universal = require("@modern-js/utils/universal");
+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, locals, metrics }) => {
+    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) {
+      return new Response((0, import_utils.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 (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, nodeReq) {
+  const query = (0, import_utils.parseQuery)(req);
+  const fallbackHeader = `x-${(0, import_universal.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 } = 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
+});