@modern-js/server-core 2.69.5 → 3.0.0-alpha.0

package/dist/esm-node/plugins/log.js

@@ -1,73 +0,0 @@
-import { getPathname } from "../utils";
-var LogPrefix;
-(function(LogPrefix2) {
-  LogPrefix2["Outgoing"] = "-->";
-  LogPrefix2["Incoming"] = "<--";
-  LogPrefix2["Error"] = "xxx";
-})(LogPrefix || (LogPrefix = {}));
-const humanize = (times) => {
-  const [delimiter, separator] = [
-    ",",
-    "."
-  ];
-  const orderTimes = times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, `$1${delimiter}`));
-  return orderTimes.join(separator);
-};
-const time = (start) => {
-  const delta = Date.now() - start;
-  return humanize([
-    delta < 1e3 ? `${delta}ms` : `${Math.round(delta / 1e3)}s`
-  ]);
-};
-const colorStatus = (status) => {
-  const out = {
-    7: `\x1B[35m${status}\x1B[0m`,
-    5: `\x1B[31m${status}\x1B[0m`,
-    4: `\x1B[33m${status}\x1B[0m`,
-    3: `\x1B[36m${status}\x1B[0m`,
-    2: `\x1B[32m${status}\x1B[0m`,
-    1: `\x1B[32m${status}\x1B[0m`,
-    0: `\x1B[33m${status}\x1B[0m`
-  };
-  const calculateStatus = Math.floor(status / 100);
-  return out[calculateStatus];
-};
-function log(fn, prefix, method, path, status = 0, elapsed) {
-  const out = prefix === "<--" ? `  ${prefix} ${method} ${path}` : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;
-  fn(out);
-}
-function logHandler() {
-  return async function logger(c, next) {
-    var _c_env_node_res, _c_env_node, _c_env;
-    const { method } = c.req;
-    const monitors = c.get("monitors");
-    if (!monitors) {
-      await next();
-      return;
-    }
-    const path = getPathname(c.req.raw);
-    const logFn = monitors.debug;
-    log(logFn, "<--", method, path);
-    const start = Date.now();
-    await next();
-    var _c_env_node_res_statusCode;
-    log(logFn, "-->", method, path, (_c_env_node_res_statusCode = c === null || c === void 0 ? void 0 : (_c_env = c.env) === null || _c_env === void 0 ? void 0 : (_c_env_node = _c_env.node) === null || _c_env_node === void 0 ? void 0 : (_c_env_node_res = _c_env_node.res) === null || _c_env_node_res === void 0 ? void 0 : _c_env_node_res.statusCode) !== null && _c_env_node_res_statusCode !== void 0 ? _c_env_node_res_statusCode : c.res.status, time(start));
-  };
-}
-const logPlugin = () => ({
-  name: "@modern-js/plugin-log",
-  setup(api) {
-    return {
-      prepare() {
-        const { middlewares } = api.useAppContext();
-        middlewares.push({
-          name: "print_log",
-          handler: logHandler()
-        });
-      }
-    };
-  }
-});
-export {
-  logPlugin
-};

package/dist/esm-node/plugins/middlewares.js

@@ -1,19 +0,0 @@
-const injectConfigMiddlewarePlugin = (configMiddlewares = [], configRenderMiddlewares = []) => ({
-  name: "@modern-js/plugin-inject-config-middleware",
-  setup(api) {
-    return {
-      prepare() {
-        const { middlewares, renderMiddlewares } = api.useAppContext();
-        configMiddlewares.forEach((m) => {
-          middlewares.push(m);
-        });
-        configRenderMiddlewares.forEach((m) => {
-          renderMiddlewares.push(m);
-        });
-      }
-    };
-  }
-});
-export {
-  injectConfigMiddlewarePlugin
-};

package/dist/esm-node/plugins/monitors.js

@@ -1,174 +0,0 @@
-import { time } from "@modern-js/runtime-utils/time";
-import { SERVER_TIMING, ServerTimings } from "../constants";
-function createMonitors() {
-  const coreMonitors = [];
-  const log = (level, message, args) => {
-    const event = {
-      type: "log",
-      payload: {
-        level,
-        message,
-        args
-      }
-    };
-    coreMonitors.forEach((monitor) => monitor(event));
-  };
-  const mointors = {
-    push(monitor) {
-      coreMonitors.push(monitor);
-    },
-    error(message, ...args) {
-      log("error", message, args);
-    },
-    warn(message, ...args) {
-      log("warn", message, args);
-    },
-    debug(message, ...args) {
-      log("debug", message, args);
-    },
-    info(message, ...args) {
-      log("info", message, args);
-    },
-    trace(message, ...args) {
-      log("trace", message, args);
-    },
-    timing(name, dur, desc, tags, ...args) {
-      const event = {
-        type: "timing",
-        payload: {
-          name,
-          dur,
-          desc,
-          tags,
-          args
-        }
-      };
-      coreMonitors.forEach((monitor) => monitor(event));
-    },
-    counter(name, tags, ...args) {
-      const event = {
-        type: "counter",
-        payload: {
-          name,
-          args,
-          tags
-        }
-      };
-      coreMonitors.forEach((monitor) => monitor(event));
-    }
-  };
-  return mointors;
-}
-const initMonitorsPlugin = () => ({
-  name: "@modern-js/init-mointor",
-  setup(api) {
-    return {
-      prepare() {
-        const { middlewares } = api.useAppContext();
-        middlewares.push({
-          name: "init-monitor",
-          handler: async (c, next) => {
-            if (!c.get("monitors")) {
-              const monitors = createMonitors();
-              c.set("monitors", monitors);
-            }
-            return next();
-          },
-          order: "pre"
-        });
-      }
-    };
-  }
-});
-const injectloggerPlugin = (inputLogger) => ({
-  name: "@modern-js/inject-logger",
-  setup(api) {
-    const logger = inputLogger;
-    return {
-      prepare() {
-        const { middlewares } = api.useAppContext();
-        middlewares.push({
-          name: "inject-logger",
-          handler: async (c, next) => {
-            if (!c.get("logger")) {
-              c.set("logger", logger);
-            }
-            const pathname = c.req.path;
-            const loggerMonitor = (event) => {
-              if (event.type === "log") {
-                const { level, message, args } = event.payload;
-                if (level === "trace") {
-                  logger.info(message, ...args || []);
-                } else {
-                  logger[level](message, ...args || []);
-                }
-              }
-              if (event.type === "timing") {
-                const { name, dur, desc } = event.payload;
-                if (desc) {
-                  logger.debug(`%s Debug - ${name}, cost: %s, req.url = %s `, desc, dur, pathname);
-                } else {
-                  logger.debug(`Debug - ${name}, cost: %s, req.url = %s`, dur, pathname);
-                }
-              }
-            };
-            const monitors = c.get("monitors");
-            monitors === null || monitors === void 0 ? void 0 : monitors.push(loggerMonitor);
-            return next();
-          }
-        });
-      }
-    };
-  }
-});
-const injectServerTiming = () => ({
-  name: "@modern-js/inject-server-timing",
-  setup(api) {
-    return {
-      prepare() {
-        const { middlewares, metaName } = api.useAppContext();
-        middlewares.push({
-          name: "inject-server-timing",
-          handler: async (c, next) => {
-            const serverTimings = [];
-            const timingMonitor = (event) => {
-              if (event.type === "timing") {
-                serverTimings.push(event.payload);
-              }
-            };
-            const monitors = c.get("monitors");
-            monitors === null || monitors === void 0 ? void 0 : monitors.push(timingMonitor);
-            await next();
-            serverTimings.forEach((serverTiming) => {
-              const { name, desc, dur } = serverTiming;
-              const _name = `bd-${metaName}-${name}`;
-              const value = `${_name};${desc ? `decs="${desc}";` : ""} dur=${dur}`;
-              c.header(SERVER_TIMING, value, {
-                append: true
-              });
-            });
-          }
-        });
-      }
-    };
-  }
-});
-function requestLatencyMiddleware() {
-  return async (c, next) => {
-    const monitors = c.get("monitors");
-    if (!monitors) {
-      await next();
-      return;
-    }
-    const getCost = time();
-    await next();
-    const cost = getCost();
-    monitors.timing(ServerTimings.SERVER_HANDLE_REQUEST, cost);
-  };
-}
-export {
-  initMonitorsPlugin,
-  injectServerTiming,
-  injectloggerPlugin,
-  requestLatencyMiddleware
-};

package/dist/esm-node/plugins/processedBy.js

@@ -1,20 +0,0 @@
-const processedByPlugin = () => ({
-  name: "@modern-js/plugin-processed",
-  setup(api) {
-    return {
-      prepare() {
-        const { middlewares } = api.useAppContext();
-        middlewares.push({
-          name: "processed-by",
-          handler: async (c, next) => {
-            await next();
-            c.header("X-Processed-By", "Modern.js");
-          }
-        });
-      }
-    };
-  }
-});
-export {
-  processedByPlugin
-};

package/dist/esm-node/plugins/render/csrRscRender.js

@@ -1,54 +0,0 @@
-import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-import { createRequestHandlerConfig } from "./utils";
-const csrRscRender = async (req, options) => {
-  var _serverManifest_renderBundles;
-  const { routeInfo, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, reporter, monitors, logger, metrics, onError, onTiming, staticGenerate, html } = options;
-  const serverBundle = serverManifest === null || serverManifest === void 0 ? void 0 : (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[routeInfo.entryName || MAIN_ENTRY_NAME];
-  const loadableStats = serverManifest.loadableStats || {};
-  const routeManifest = serverManifest.routeManifest || {};
-  const config = createRequestHandlerConfig(options.config);
-  const requestHandlerOptions = {
-    resource: {
-      route: routeInfo,
-      loadableStats,
-      routeManifest,
-      entryName: routeInfo.entryName || MAIN_ENTRY_NAME
-    },
-    config,
-    params,
-    loaderContext,
-    html,
-    rscSSRManifest,
-    rscClientManifest,
-    rscServerManifest,
-    locals,
-    reporter,
-    staticGenerate,
-    logger,
-    metrics,
-    monitors,
-    onError,
-    onTiming
-  };
-  if (!serverBundle) {
-    return new Response("Cannot find server bundle for RSC", {
-      status: 500
-    });
-  }
-  const renderRscStreamHandler = await serverBundle.renderRscStreamHandler;
-  if (!renderRscStreamHandler) {
-    return new Response("Cannot find render handler for RSC", {
-      status: 500
-    });
-  }
-  if (!rscClientManifest) {
-    return new Response("Cannot find rsc client manifest", {
-      status: 500
-    });
-  }
-  const response = await renderRscStreamHandler(req, requestHandlerOptions);
-  return response;
-};
-export {
-  csrRscRender
-};

package/dist/esm-node/plugins/render/dataHandler.js

@@ -1,25 +0,0 @@
-import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-const dataHandler = async (request, { routeInfo, serverRoutes, reporter, monitors, onError, onTiming, serverManifest, loaderContext }) => {
-  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: {
-      reporter,
-      monitors,
-      loaderContext
-    },
-    onTiming,
-    onError,
-    routes
-  });
-  return response;
-};
-export {
-  dataHandler
-};

package/dist/esm-node/plugins/render/index.js

@@ -1,106 +0,0 @@
-import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-import { getLoaderCtx } from "../../helper";
-import { sortRoutes } from "../../utils";
-import { CustomServer } from "../customServer";
-import { requestLatencyMiddleware } from "../monitors";
-export * from "./inject";
-const renderPlugin = () => ({
-  name: "@modern-js/plugin-render",
-  setup(api) {
-    return {
-      async prepare() {
-        const { middlewares, routes, render, distDirectory: pwd, renderMiddlewares } = api.useAppContext();
-        const hooks = api.getHooks();
-        const config = api.useConfigContext();
-        if (!routes) {
-          return;
-        }
-        const customServer = new CustomServer(hooks, pwd);
-        const pageRoutes = getPageRoutes(routes);
-        middlewares.push({
-          name: "page-latency",
-          handler: requestLatencyMiddleware()
-        });
-        for (const route of pageRoutes) {
-          var _config_server;
-          const { urlPath: originUrlPath, entryName = MAIN_ENTRY_NAME } = route;
-          const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
-          if (((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.disableHook) !== true) {
-            const customServerHookMiddleware = customServer.getHookMiddleware(entryName, routes);
-            middlewares.push({
-              name: "custom-server-hook",
-              path: urlPath,
-              handler: customServerHookMiddleware
-            });
-          }
-          renderMiddlewares === null || renderMiddlewares === void 0 ? void 0 : renderMiddlewares.forEach((m) => {
-            middlewares.push({
-              name: m.name,
-              path: urlPath,
-              handler: m.handler
-            });
-          });
-          const customServerMiddleware = await customServer.getServerMiddleware();
-          customServerMiddleware && middlewares.push({
-            name: "custom-server-middleware",
-            path: urlPath,
-            handler: customServerMiddleware
-          });
-          render && middlewares.push({
-            name: `render`,
-            path: urlPath,
-            handler: createRenderHandler(render)
-          });
-        }
-      }
-    };
-  }
-});
-function getPageRoutes(routes) {
-  return routes.filter((route) => !route.isApi).sort(sortRoutes);
-}
-function createRenderHandler(render) {
-  return async (c, _) => {
-    var _c_env_node;
-    const logger = c.get("logger");
-    const reporter = c.get("reporter");
-    const monitors = c.get("monitors");
-    const templates = c.get("templates") || {};
-    const serverManifest = c.get("serverManifest") || {};
-    const rscServerManifest = c.get("rscServerManifest");
-    const rscClientManifest = c.get("rscClientManifest");
-    const rscSSRManifest = c.get("rscSSRManifest");
-    const locals = c.get("locals");
-    const metrics = c.get("metrics");
-    const matchPathname = c.get("matchPathname");
-    const matchEntryName = c.get("matchEntryName");
-    const loaderContext = getLoaderCtx(c);
-    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, {
-      nodeReq,
-      monitors,
-      logger,
-      reporter,
-      templates,
-      metrics,
-      serverManifest,
-      rscServerManifest,
-      rscClientManifest,
-      rscSSRManifest,
-      loaderContext,
-      locals,
-      matchPathname,
-      matchEntryName
-    });
-    const { body, status, headers } = res;
-    const headersData = {};
-    headers.forEach((v, k) => {
-      headersData[k] = v;
-    });
-    return c.body(body, status, headersData);
-  };
-}
-export {
-  renderPlugin
-};

package/dist/esm-node/plugins/render/inject.js

@@ -1,69 +0,0 @@
-import { createRender } from "./render";
-const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig }) => ({
-  name: "@modern-js/plugin-inject-render",
-  setup(api) {
-    return {
-      async prepare() {
-        const { distDirectory: pwd, routes, metaName } = api.useAppContext();
-        const config = api.useConfigContext();
-        const hookRunner = api.useHookRunners();
-        if (!routes) {
-          return;
-        }
-        const onFallback = async (reason, utils, error) => {
-          await hookRunner.fallback({
-            reason,
-            ...utils,
-            error
-          });
-        };
-        const getRenderHandlerOptions = {
-          pwd,
-          routes,
-          config,
-          metaName,
-          // TODO: support modern.server.ts cache config
-          cacheConfig,
-          staticGenerate,
-          onFallback
-        };
-        const render = await getRenderHandler(getRenderHandlerOptions);
-        api.setAppContext({
-          ...api.useAppContext(),
-          render,
-          getRenderOptions: getRenderHandlerOptions
-        });
-      }
-    };
-  }
-});
-async function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate, onFallback }) {
-  var _config_server, _config_server1, _config_security;
-  const ssrConfig = (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr;
-  const ssrByEntries = (_config_server1 = config.server) === null || _config_server1 === void 0 ? void 0 : _config_server1.ssrByEntries;
-  const forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
-  const forceCSRMap = /* @__PURE__ */ new Map();
-  if (ssrByEntries) {
-    Object.entries(ssrByEntries).forEach(([entryName, ssrConfig2]) => {
-      var _ssrConfig_forceCSR;
-      forceCSRMap.set(entryName, typeof ssrConfig2 === "object" ? (_ssrConfig_forceCSR = ssrConfig2.forceCSR) !== null && _ssrConfig_forceCSR !== void 0 ? _ssrConfig_forceCSR : false : false);
-    });
-  }
-  const render = createRender({
-    routes,
-    pwd,
-    config,
-    staticGenerate,
-    cacheConfig,
-    forceCSR,
-    forceCSRMap,
-    nonce: (_config_security = config.security) === null || _config_security === void 0 ? void 0 : _config_security.nonce,
-    metaName: metaName || "modern-js",
-    onFallback
-  });
-  return render;
-}
-export {
-  getRenderHandler,
-  injectRenderHandlerPlugin
-};