@modern-js/server-core 2.54.5 → 2.55.0

package/dist/cjs/index.js

@@ -36,6 +36,7 @@ __reExport(src_exports, require("./types/plugin"), module.exports);
 __reExport(src_exports, require("./types/render"), module.exports);
 __reExport(src_exports, require("@modern-js/plugin"), module.exports);
 __reExport(src_exports, require("./types/config"), module.exports);
+__reExport(src_exports, require("./types/requestHandler"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGGRED_DIR,
@@ -48,5 +49,6 @@ __reExport(src_exports, require("./types/config"), module.exports);
   ...require("./types/plugin"),
   ...require("./types/render"),
   ...require("@modern-js/plugin"),
-  ...require("./types/config")
+  ...require("./types/config"),
+  ...require("./types/requestHandler")
 });

package/dist/cjs/plugins/render/dataHandler.js

@@ -22,7 +22,7 @@ __export(dataHandler_exports, {
 });
 module.exports = __toCommonJS(dataHandler_exports);
 var import_constants = require("@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 || import_constants.MAIN_ENTRY_NAME];
   if (!serverLoaderModule) {
@@ -33,9 +33,10 @@ const dataHandler = async (request, { routeInfo, serverRoutes, reporter, logger,
     request,
     serverRoutes,
     context: {
-      logger,
       reporter
     },
+    onTiming,
+    onError,
     routes
   });
   return response;

package/dist/cjs/plugins/render/index.js

@@ -120,7 +120,7 @@ async function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, st
   const render = (0, import_render.createRender)({
     routes,
     pwd,
-    // TODO: need static Genrate
+    config,
     staticGenerate,
     cacheConfig,
     forceCSR,

package/dist/cjs/plugins/render/render.js

@@ -27,6 +27,7 @@ var import_utils = require("../../utils");
 var import_constants = require("../../constants");
 var import_dataHandler = require("./dataHandler");
 var import_ssrRender = require("./ssrRender");
+var import_serverTiming = require("./serverTiming");
 const DYNAMIC_ROUTE_REG = /\/:./;
 function getRouter(routes) {
   const dynamicRoutes = [];
@@ -56,7 +57,16 @@ 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;
+}
+const SERVER_TIMING = "Server-Timing";
+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 }) => {
     const [routeInfo, params] = matchRoute(router, req);
@@ -85,7 +95,17 @@ 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) => {
+    const pathname = (0, import_utils.getPathname)(req);
+    const headerData = (0, import_utils.parseHeaders)(req);
+    const serverTimingInstance = new import_serverTiming.ServerTiming(metaName || "modern");
+    const onError = (e) => {
+      logger.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) => {
+      logger.debug(`SSR Debug - ${name}, cost = %s, req.url = %s`, dur, pathname);
+      serverTimingInstance.addServeTiming(name, dur);
+    };
+    const onBoundError = async (e) => {
       (0, import_utils.onError)(import_utils.ErrorDigest.ERENDER, e, logger, req);
       await (onFallback === null || onFallback === void 0 ? void 0 : onFallback("error", e));
     };
@@ -94,32 +114,36 @@ 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 (0, import_dataHandler.dataHandler)(req, renderOptions);
-        if (!response) {
-          response = await renderHandler(req, renderOptions, "ssr", onError);
-        }
-        return response;
+        response = await (0, import_dataHandler.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}`);
     }
+    serverTimingInstance.headers.forEach((value) => {
+      response.headers.append(SERVER_TIMING, value);
+    });
+    return response;
   };
 }
 async function renderHandler(request, options, mode, onError) {

package/dist/cjs/plugins/render/serverTiming.js

@@ -21,17 +21,19 @@ __export(serverTiming_exports, {
   ServerTiming: () => ServerTiming
 });
 module.exports = __toCommonJS(serverTiming_exports);
-const SERVER_TIMING = "Server-Timing";
 class ServerTiming {
+  get headers() {
+    return this.headerList;
+  }
   addServeTiming(name, dur, desc) {
     const _name = `bd-${this.meta}-${name}`;
     const value = `${_name};${desc ? `decs="${desc}";` : ""} dur=${dur}`;
-    this.headers.append(SERVER_TIMING, value);
+    this.headerList.push(value);
     return this;
   }
-  constructor(headers, meta) {
+  constructor(meta) {
+    this.headerList = [];
     this.meta = meta;
-    this.headers = headers;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/plugins/render/ssrCache.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   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, {
@@ -33,72 +23,42 @@ __export(ssrCache_exports, {
 });
 module.exports = __toCommonJS(ssrCache_exports);
 var import_storer = require("@modern-js/runtime-utils/storer");
+var import_constants = require("../../constants");
 var import_utils = require("../../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 Promise.resolve().then(() => __toESM(require("stream"))).catch((_) => ({
-      Readable: void 0
-    }));
-    const runtimeEnv = (0, import_utils.getRuntimeEnv)();
-    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 body = (
-      // TODO: remove node:stream, move it to ssr entry.
-      Readable && renderResult instanceof Readable ? createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(renderResult) : renderResult
-    );
+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 = (0, import_utils.createTransformStream)();
+    const reader = response.body.getReader();
+    const writer = stream.writable.getWriter();
     let html = "";
-    const stream = (0, import_utils.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(import_constants.X_RENDER_CACHE, cacheStatus);
+    return new Response(stream.readable, {
+      status: response.status,
+      headers: response.headers
+    });
   }
+  return response;
 }
 const CACHE_NAMESPACE = "__ssr__cache";
 const storage = (0, import_storer.createMemoryStorage)(CACHE_NAMESPACE);
@@ -145,7 +105,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;
@@ -154,21 +114,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: {
+          [import_constants.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: {
+          [import_constants.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"
+    });
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/plugins/render/ssrRender.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,48 +15,22 @@ var __copyProps = (to, from, except, desc) => {
   }
   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, {
-  getPathnameFromNodeReq: () => getPathnameFromNodeReq,
   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");
 var import_ssrCache = require("./ssrCache");
-const defaultReporter = {
-  init() {
-  },
-  reportError() {
-  },
-  reportTiming() {
-  },
-  reportInfo() {
-  },
-  reportWarn() {
-  }
-};
-async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, cacheConfig }) {
+const SERVER_RUNTIME_ENTRY = "requestHandler";
+async function ssrRender(request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, locals, params, loaderContext, reporter, cacheConfig, logger, metrics, onError, onTiming }) {
   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);
   if (nodeReq) {
     for (const key in nodeReq.headers) {
@@ -67,103 +39,46 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
       }
     }
   }
-  const ssrContext = {
-    request: {
-      baseUrl: routeInfo.urlPath,
-      params,
-      pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : (0, import_utils.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 || {}
+  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 requestHandler = await renderBundle[SERVER_RUNTIME_ENTRY];
+  const config = createRequestHandlerConfig(userConfig);
+  const requestHandlerOptions = {
+    resource: {
+      route: routeInfo,
+      loadableStats,
+      routeManifest,
+      htmlTemplate: html,
+      entryName: entryName || import_constants.MAIN_ENTRY_NAME
     },
-    redirection: {},
-    template: html,
-    loadableStats,
+    params,
     loaderContext,
-    routeManifest,
-    entryName,
+    config,
+    locals,
+    reporter,
     staticGenerate,
     logger,
     metrics,
-    serverTiming: new import_serverTiming.ServerTiming(responseProxy.headers, metaName),
-    reporter: reporter || defaultReporter,
-    /** @deprecated node req */
-    req: nodeReq || request,
-    /** @deprecated node res  */
-    res: void 0,
-    isSpider,
-    nonce
+    onError,
+    onTiming
   };
-  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];
   const cacheControl = await (0, import_ssrCache.matchCacheControl)(cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.strategy, nodeReq || new IncomingMessgeProxy(request));
+  let response;
   if (cacheControl) {
-    const { data: data2, status } = await (0, import_ssrCache.getCacheResult)(request, {
+    response = await (0, import_ssrCache.getCacheResult)(request, {
       cacheControl,
       container: cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.container,
-      render,
-      ssrContext
+      requestHandler,
+      requestHandlerOptions
     });
-    ssrResult = data2;
-    cacheStatus = status;
   } else {
-    ssrResult = await render(ssrContext);
-  }
-  const { redirection } = ssrContext;
-  if (cacheStatus) {
-    responseProxy.headers.set(import_constants2.X_RENDER_CACHE, cacheStatus);
-  }
-  responseProxy.headers.set(import_constants2.X_MODERNJS_RENDER, "server");
-  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;
-  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");
+    response = await requestHandler(request, requestHandlerOptions);
   }
+  response.headers.set(import_constants2.X_MODERNJS_RENDER, "server");
+  response.headers.set("content-type", "text/html; charset=UTF-8");
+  return response;
 }
 class IncomingMessgeProxy {
   constructor(req) {
@@ -175,39 +90,19 @@ class IncomingMessgeProxy {
     this.url = (0, import_utils.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;
+function createRequestHandlerConfig(userConfig) {
+  const { output, server, security, html } = userConfig;
+  return {
+    ssr: server === null || server === void 0 ? void 0 : server.ssr,
+    ssrByEntries: server === null || server === void 0 ? void 0 : server.ssrByEntries,
+    nonce: security === null || security === void 0 ? void 0 : security.nonce,
+    enableInlineScripts: output === null || output === void 0 ? void 0 : output.enableInlineScripts,
+    enableInlineStyles: output === null || output === void 0 ? void 0 : output.enableInlineStyles,
+    crossorigin: html === null || html === void 0 ? void 0 : html.crossorigin,
+    scriptLoading: html === null || html === void 0 ? void 0 : html.scriptLoading
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getPathnameFromNodeReq,
   ssrRender
 });

package/dist/cjs/types/requestHandler.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 requestHandler_exports = {};
+module.exports = __toCommonJS(requestHandler_exports);

package/dist/cjs/utils/transformStream.js

@@ -28,7 +28,7 @@ function createTransformStream(fn) {
   return new TransformStream({
     async transform(chunk, controller) {
       const content = decoder.decode(chunk);
-      const newContent = await fn(content);
+      const newContent = fn ? await fn(content) : content;
       controller.enqueue(encoder.encode(newContent));
     }
   });

package/dist/esm/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/plugins/render/dataHandler.js

@@ -3,11 +3,11 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
 var dataHandler = function() {
   var _ref = _async_to_generator(function(request, param) {
-    var routeInfo, serverRoutes, reporter, logger, serverManifest, _serverManifest_loaderBundles, serverLoaderModule, routes, handleRequest, response;
+    var routeInfo, serverRoutes, reporter, onError, onTiming, serverManifest, _serverManifest_loaderBundles, serverLoaderModule, routes, handleRequest, response;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          routeInfo = param.routeInfo, serverRoutes = param.serverRoutes, reporter = param.reporter, logger = param.logger, serverManifest = param.serverManifest;
+          routeInfo = param.routeInfo, serverRoutes = param.serverRoutes, reporter = param.reporter, onError = param.onError, onTiming = param.onTiming, serverManifest = param.serverManifest;
           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 [
@@ -21,9 +21,10 @@ var dataHandler = function() {
               request,
               serverRoutes,
               context: {
-                logger,
                 reporter
               },
+              onTiming,
+              onError,
               routes
             })
           ];