@modern-js/server-core 2.54.6 → 2.56.0

package/dist/esm-node/constants.js

@@ -15,19 +15,21 @@ const REPLACE_REG = {
     body: "</body>"
   }
 };
-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 = {}));
+var ServerTimings;
+(function(ServerTimings2) {
+  ServerTimings2["SERVER_HANDLE_REQUEST"] = "server-handle-request";
+  ServerTimings2["SERVER_MIDDLEWARE"] = "server-middleware";
+  ServerTimings2["SERVER_HOOK_AFTER_RENDER"] = "server-hook-after-render";
+  ServerTimings2["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
+})(ServerTimings || (ServerTimings = {}));
+const SERVER_TIMING = "Server-Timing";
 const X_RENDER_CACHE = "x-render-cache";
 const X_MODERNJS_RENDER = "x-modernjs-render";
 export {
   AGGRED_DIR,
   REPLACE_REG,
-  ServerReportTimings,
+  SERVER_TIMING,
+  ServerTimings,
   X_MODERNJS_RENDER,
   X_RENDER_CACHE
 };

package/dist/esm-node/index.js

@@ -7,6 +7,7 @@ export * from "./types/plugin";
 export * from "./types/render";
 export * from "@modern-js/plugin";
 export * from "./types/config";
+export * from "./types/requestHandler";
 export {
   AGGRED_DIR,
   ErrorDigest,

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

@@ -1,6 +1,6 @@
 import { time } from "@modern-js/runtime-utils/time";
 import { transformResponse } from "../../utils";
-import { ServerReportTimings } from "../../constants";
+import { ServerTimings } from "../../constants";
 import { getLoaderCtx } from "./loader";
 import { getAfterMatchCtx, getAfterRenderCtx, createCustomMiddlewaresCtx, createAfterStreamingRenderContext } from "./context";
 import { createBaseHookContext } from "./base";
@@ -15,7 +15,7 @@ class CustomServer {
   getHookMiddleware(entryName, routes) {
     return async (c, next) => {
       const routeInfo = routes.find((route) => route.entryName === entryName);
-      const reporter = c.get("reporter");
+      const monitors = c.get("monitors");
       const baseHookCtx = createBaseHookContext(c);
       const afterMatchCtx = getAfterMatchCtx(entryName, baseHookCtx);
       const getCost = time();
@@ -23,7 +23,7 @@ class CustomServer {
         onLast: noop
       });
       const cost = getCost();
-      cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost));
+      cost && (monitors === null || monitors === void 0 ? void 0 : monitors.timing(ServerTimings.SERVER_HOOK_AFTER_MATCH, cost));
       const { url, status } = afterMatchCtx.router;
       if (url) {
         return c.redirect(url, status);
@@ -63,7 +63,7 @@ class CustomServer {
           onLast: noop
         });
         const cost2 = getCost2();
-        cost2 && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_RENDER, cost2));
+        cost2 && (monitors === null || monitors === void 0 ? void 0 : monitors.timing(ServerTimings.SERVER_HOOK_AFTER_RENDER, cost2));
         if (afterRenderCtx.response.private_overrided) {
           return void 0;
         }
@@ -82,7 +82,7 @@ class CustomServer {
     }
     return async (c, next) => {
       var _c_env_node_res, _c_env_node, _c_env;
-      const reporter = c.get("reporter");
+      const monitors = c.get("monitors");
       const locals = {};
       const resArgs = {
         headers: new Headers()
@@ -91,7 +91,7 @@ class CustomServer {
       const getCost = time();
       await serverMiddleware(customMiddlewareCtx);
       const cost = getCost();
-      cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_MIDDLEWARE, cost));
+      cost && (monitors === null || monitors === void 0 ? void 0 : monitors.timing(ServerTimings.SERVER_MIDDLEWARE, cost));
       c.set("locals", locals);
       if (isRedirect(resArgs.headers, resArgs.status)) {
         return c.redirect(resArgs.headers.get("Location") || "", resArgs.status || 302);

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

@@ -3,13 +3,15 @@ import { faviconPlugin } from "./favicon";
 import { processedByPlugin } from "./processedBy";
 import { getLoaderCtx } from "./customServer";
 import { logPlugin } from "./log";
-import { monitorPlugin } from "./monitor";
+import { initMonitorsPlugin, injectServerTiming, injectloggerPluigin } from "./monitors";
 export {
   faviconPlugin,
   getLoaderCtx,
   getRenderHandler,
+  initMonitorsPlugin,
+  injectServerTiming,
+  injectloggerPluigin,
   logPlugin,
-  monitorPlugin,
   processedByPlugin,
   renderPlugin
 };

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

@@ -39,13 +39,13 @@ function log(fn, prefix, method, path, status = 0, elapsed) {
 function logHandler() {
   return async function logger(c, next) {
     const { method } = c.req;
-    const logger2 = c.get("logger");
-    if (!logger2) {
+    const monitors = c.get("monitors");
+    if (!monitors) {
       await next();
       return;
     }
     const path = getPathname(c.req.raw);
-    const logFn = logger2.debug;
+    const logFn = monitors.debug;
     log(logFn, "<--", method, path);
     const start = Date.now();
     await next();

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

@@ -0,0 +1,156 @@
+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);
+    },
+    timing(name, dur, desc) {
+      const event = {
+        type: "timing",
+        payload: {
+          name,
+          dur,
+          desc
+        }
+      };
+      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 injectloggerPluigin = (logger) => ({
+  name: "@modern-js/inject-logger",
+  setup(api) {
+    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;
+                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 = (metaName = "modern-js") => ({
+  name: "@modern-js/inject-server-timing",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares } = 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 initReporter(entryName) {
+  return async (c, next) => {
+    const reporter = c.get("reporter");
+    if (!reporter) {
+      await next();
+      return;
+    }
+    await reporter.init({
+      entryName
+    });
+    const getCost = time();
+    await next();
+    const cost = getCost();
+    reporter.reportTiming(ServerTimings.SERVER_HANDLE_REQUEST, cost);
+  };
+}
+export {
+  initMonitorsPlugin,
+  initReporter,
+  injectServerTiming,
+  injectloggerPluigin
+};

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

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

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

@@ -1,5 +1,5 @@
 import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-import { initReporter } from "../monitor";
+import { initReporter } from "../monitors";
 import { sortRoutes } from "../../utils";
 import { getLoaderCtx, CustomServer, getServerMidFromUnstableMid } from "../customServer";
 import { createRender } from "./render";
@@ -64,6 +64,7 @@ function createRenderHandler(render) {
     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 locals = c.get("locals");
@@ -72,8 +73,9 @@ function createRenderHandler(render) {
     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,
+      monitors,
+      logger,
       reporter,
       templates,
       metrics,
@@ -96,7 +98,7 @@ async function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, st
   const render = createRender({
     routes,
     pwd,
-    // TODO: need static Genrate
+    config,
     staticGenerate,
     cacheConfig,
     forceCSR,

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

@@ -1,6 +1,6 @@
 import { cutNameByHyphen } from "@modern-js/utils/universal";
 import { TrieRouter } from "hono/router/trie-router";
-import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse, onError as onErrorFn, ErrorDigest } from "../../utils";
+import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse, onError as onErrorFn, ErrorDigest, parseHeaders } from "../../utils";
 import { REPLACE_REG, X_MODERNJS_RENDER } from "../../constants";
 import { dataHandler } from "./dataHandler";
 import { ssrRender } from "./ssrRender";
@@ -33,9 +33,17 @@ function matchRoute(router, request) {
   const result = matched[0][0];
   return result || [];
 }
-async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, nonce, onFallback: onFallbackFn }) {
+function getHeadersWithoutCookie(headers) {
+  const _headers = {
+    ...headers,
+    cookie: void 0
+  };
+  delete _headers.cookie;
+  return _headers;
+}
+async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, config, onFallback: onFallbackFn }) {
   const router = getRouter(routes);
-  return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals, metrics, loaderContext }) => {
+  return async (req, { logger, reporter, metrics, monitors, nodeReq, templates, serverManifest, locals, loaderContext }) => {
     const [routeInfo, params] = matchRoute(router, req);
     const onFallback = async (reason, error) => {
       return onFallbackFn === null || onFallbackFn === void 0 ? void 0 : onFallbackFn(reason, {
@@ -62,8 +70,16 @@ async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig
       });
     }
     const renderMode = await getRenderMode(req, metaName || "modern-js", routeInfo.isSSR, forceCSR, nodeReq, onFallback);
-    const onError = async (e) => {
-      onErrorFn(ErrorDigest.ERENDER, e, logger, req);
+    const pathname = getPathname(req);
+    const headerData = parseHeaders(req);
+    const onError = (e) => {
+      monitors === null || monitors === void 0 ? void 0 : monitors.error(`SSR Error - ${e instanceof Error ? e.name : e}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, pathname, getHeadersWithoutCookie(headerData));
+    };
+    const onTiming = (name, dur) => {
+      monitors === null || monitors === void 0 ? void 0 : monitors.timing(name, dur, "SSR");
+    };
+    const onBoundError = async (e) => {
+      onErrorFn(ErrorDigest.ERENDER, e, monitors, req);
       await (onFallback === null || onFallback === void 0 ? void 0 : onFallback("error", e));
     };
     const renderOptions = {
@@ -71,32 +87,33 @@ async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig
       html,
       routeInfo,
       staticGenerate: staticGenerate || false,
-      metaName: metaName || "modern-js",
-      nonce,
-      logger,
+      config,
       nodeReq,
       cacheConfig,
       reporter,
       serverRoutes: routes,
       params,
+      logger,
+      metrics,
       locals,
       serverManifest,
-      metrics,
-      loaderContext: loaderContext || /* @__PURE__ */ new Map()
+      loaderContext: loaderContext || /* @__PURE__ */ new Map(),
+      onError,
+      onTiming
     };
+    let response;
     switch (renderMode) {
       case "data":
-        let response = await dataHandler(req, renderOptions);
-        if (!response) {
-          response = await renderHandler(req, renderOptions, "ssr", onError);
-        }
-        return response;
+        response = await dataHandler(req, renderOptions) || await renderHandler(req, renderOptions, "ssr", onBoundError);
+        break;
       case "ssr":
       case "csr":
-        return renderHandler(req, renderOptions, renderMode, onError);
+        response = await renderHandler(req, renderOptions, renderMode, onBoundError);
+        break;
       default:
         throw new Error(`Unknown render mode: ${renderMode}`);
     }
+    return response;
   };
 }
 async function renderHandler(request, options, mode, onError) {

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

@@ -1,70 +1,40 @@
 import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
-import { createTransformStream, getPathname, getRuntimeEnv } from "../../utils";
-async function processCache(key, render, ssrContext, ttl, container, 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 container.set(key, JSON.stringify(cache), {
-      ttl
-    });
-    return {
-      data: renderResult,
-      status
-    };
-  } else {
-    const { Readable } = await import("stream").catch((_) => ({
-      Readable: void 0
-    }));
-    const runtimeEnv = getRuntimeEnv();
-    const streamModule = "../../adapters/node/polyfills/stream";
-    const { createReadableStreamFromReadable } = runtimeEnv === "node" ? await import(streamModule).catch((_) => ({
-      createReadableStreamFromReadable: void 0
-    })) : {
-      createReadableStreamFromReadable: void 0
-    };
-    const body = (
-      // TODO: remove node:stream, move it to ssr entry.
-      Readable && renderResult instanceof Readable ? createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(renderResult) : renderResult
-    );
+import { X_RENDER_CACHE } from "../../constants";
+import { createTransformStream, getPathname } from "../../utils";
+async function processCache({ request, key, requestHandler, requestHandlerOptions, ttl, container, cacheStatus }) {
+  const response = await requestHandler(request, requestHandlerOptions);
+  const decoder = new TextDecoder();
+  if (response.body) {
+    const stream = createTransformStream();
+    const reader = response.body.getReader();
+    const writer = stream.writable.getWriter();
     let html = "";
-    const stream = createTransformStream((chunk) => {
-      html += chunk;
-      return chunk;
+    const push = () => reader.read().then(({ done, value }) => {
+      if (done) {
+        const current = Date.now();
+        const cache = {
+          val: html,
+          cursor: current
+        };
+        container.set(key, JSON.stringify(cache), {
+          ttl
+        });
+        writer.close();
+        return;
+      }
+      const content = decoder.decode(value);
+      html += content;
+      writer.write(value);
+      push();
     });
-    const reader = body.getReader();
-    const writer = stream.writable.getWriter();
-    const push = () => {
-      reader.read().then(({ done, value }) => {
-        if (done) {
-          const current = Date.now();
-          const cache = {
-            val: html,
-            cursor: current
-          };
-          container.set(key, JSON.stringify(cache), {
-            ttl
-          });
-          writer.close();
-          return;
-        }
-        writer.write(value);
-        push();
-      });
-    };
     push();
-    return {
-      data: stream.readable,
-      status
-    };
+    cacheStatus && response.headers.set(X_RENDER_CACHE, cacheStatus);
+    return new Response(stream.readable, {
+      status: response.status,
+      headers: response.headers
+    });
   }
+  return response;
 }
 const CACHE_NAMESPACE = "__ssr__cache";
 const storage = createMemoryStorage(CACHE_NAMESPACE);
@@ -111,7 +81,7 @@ function matchCacheControl(cacheOption, req) {
   }
 }
 async function getCacheResult(request, options) {
-  const { cacheControl, render, ssrContext, container = storage } = options;
+  const { cacheControl, container = storage, requestHandler, requestHandlerOptions } = options;
   const key = computedKey(request, cacheControl);
   const value = await container.get(key);
   const { maxAge, staleWhileRevalidate } = cacheControl;
@@ -120,21 +90,50 @@ async function getCacheResult(request, options) {
     const cache = JSON.parse(value);
     const interval = Date.now() - cache.cursor;
     if (interval <= maxAge) {
-      return {
-        data: cache.val,
-        status: "hit"
-      };
+      const cacheStatus = "hit";
+      return new Response(cache.val, {
+        headers: {
+          [X_RENDER_CACHE]: cacheStatus
+        }
+      });
     } else if (interval <= staleWhileRevalidate + maxAge) {
-      processCache(key, render, ssrContext, ttl, container);
-      return {
-        data: cache.val,
-        status: "stale"
-      };
+      processCache({
+        key,
+        request,
+        requestHandler,
+        requestHandlerOptions,
+        ttl,
+        container
+      }).then(async (response) => {
+        await response.text();
+      });
+      const cacheStatus = "stale";
+      return new Response(cache.val, {
+        headers: {
+          [X_RENDER_CACHE]: cacheStatus
+        }
+      });
     } else {
-      return processCache(key, render, ssrContext, ttl, container, "expired");
+      return processCache({
+        key,
+        request,
+        requestHandler,
+        requestHandlerOptions,
+        ttl,
+        container,
+        cacheStatus: "expired"
+      });
     }
   } else {
-    return processCache(key, render, ssrContext, ttl, container, "miss");
+    return processCache({
+      key,
+      request,
+      requestHandler,
+      requestHandlerOptions,
+      ttl,
+      container,
+      cacheStatus: "miss"
+    });
   }
 }
 export {