@modern-js/prod-server 2.27.0 → 2.29.0

package/dist/esm-node/libs/render/cache/spr.js

@@ -141,9 +141,10 @@ class CacheManager {
     return maybeSync(doCache)(sync);
   }
   async del(context, cacheHash) {
+    var _data;
     const cacheKey = this.generateRequestKey(context);
     const data = this.cache.get(cacheKey);
-    data === null || data === void 0 ? void 0 : data.caches.del(cacheHash);
+    (_data = data) === null || _data === void 0 ? void 0 : _data.caches.del(cacheHash);
   }
   constructor(cacheOptions) {
     _define_property(this, "cache", void 0);

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

@@ -5,7 +5,7 @@ import { handleDirectory } from "./static";
 import { readFile } from "./reader";
 import * as ssr from "./ssr";
 import { injectServerData } from "./utils";
-export const createRenderHandler = ({ distDir, staticGenerate, forceCSR, nonce, metaName = "modern-js" }) => async function render({ ctx, route, runner }) {
+export const createRenderHandler = ({ distDir, staticGenerate, forceCSR, nonce, ssrRender, metaName = "modern-js" }) => async function render({ ctx, route, runner }) {
   if (ctx.resHasHandled()) {
     return null;
   }
@@ -23,7 +23,7 @@ export const createRenderHandler = ({ distDir, staticGenerate, forceCSR, nonce,
   const useCSR = forceCSR && (ctx.query.csr || ctx.headers[`x-${cutNameByHyphen(metaName)}-ssr-fallback`]);
   if (route.isSSR && !useCSR) {
     try {
-      const result = await ssr.render(ctx, {
+      const ssrRenderOptions = {
         distDir,
         entryName: route.entryName,
         urlPath: route.urlPath,
@@ -31,7 +31,16 @@ export const createRenderHandler = ({ distDir, staticGenerate, forceCSR, nonce,
         template: content.toString(),
         staticGenerate,
         nonce
-      }, runner);
+      };
+      const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, {
+        distDir,
+        entryName: route.entryName,
+        urlPath: route.urlPath,
+        bundle: route.bundle,
+        template: content.toString(),
+        staticGenerate,
+        nonce
+      }, runner));
       return result;
     } catch (err) {
       ctx.error(ERROR_DIGEST.ERENDER, err.stack || err.message);

package/dist/esm-node/libs/render/reader.js

@@ -72,8 +72,9 @@ export class LruReader {
 }
 const reader = new LruReader();
 export const readFile = async (filepath) => {
+  var _file;
   const file = await reader.read(filepath);
-  return file === null || file === void 0 ? void 0 : file.content;
+  return (_file = file) === null || _file === void 0 ? void 0 : _file.content;
 };
 export const updateFile = () => {
   reader.update();

package/dist/esm-node/libs/render/ssr.js

@@ -11,7 +11,6 @@ export const render = async (ctx, renderOptions, runner) => {
   const loadableStats = fs.existsSync(loadableUri) ? require(loadableUri) : "";
   const routesManifestUri = path.join(distDir, ROUTE_MANIFEST_FILE);
   const routeManifest = fs.existsSync(routesManifestUri) ? require(routesManifestUri) : void 0;
-  const body = await getRequestBody(ctx.req);
   const context = {
     request: {
       baseUrl: urlPath,
@@ -21,7 +20,7 @@ export const render = async (ctx, renderOptions, runner) => {
       query: ctx.query,
       url: ctx.href,
       headers: ctx.headers,
-      body
+      body: ctx.req.body
     },
     response: {
       setHeader: (key, value) => {
@@ -40,6 +39,8 @@ export const render = async (ctx, renderOptions, runner) => {
     staticGenerate,
     logger: void 0,
     metrics: void 0,
+    reporter: ctx.reporter,
+    serverTiming: ctx.serverTiming,
     req: ctx.req,
     res: ctx.res,
     enableUnsafeCtx,
@@ -73,21 +74,3 @@ export const render = async (ctx, renderOptions, runner) => {
     };
   }
 };
-const getRequestBody = (req) => {
-  return new Promise((resolve, reject) => {
-    if ((req === null || req === void 0 ? void 0 : req.method) && req.method.toLowerCase() !== "get") {
-      let body = "";
-      req.on("data", (chunk) => {
-        body += chunk.toString();
-      });
-      req.on("end", () => {
-        resolve(body);
-      });
-      req.on("error", (err) => {
-        reject(err);
-      });
-    } else {
-      resolve(void 0);
-    }
-  });
-};

package/dist/esm-node/libs/reporter.js

@@ -0,0 +1,12 @@
+export const defaultReporter = {
+  init() {
+  },
+  reportError() {
+  },
+  reportTiming() {
+  },
+  reportInfo() {
+  },
+  reportWarn() {
+  }
+};

package/dist/esm-node/libs/route/matcher.js

@@ -39,9 +39,9 @@ export class RouteMatcher {
     if (!this.urlReg) {
       return this.urlPath.length;
     } else {
-      var _result_;
+      var _result_, _result;
       const result = this.urlReg.exec(pathname);
-      return (result === null || result === void 0 ? void 0 : (_result_ = result[0]) === null || _result_ === void 0 ? void 0 : _result_.length) || null;
+      return ((_result = result) === null || _result === void 0 ? void 0 : (_result_ = _result[0]) === null || _result_ === void 0 ? void 0 : _result_.length) || null;
     }
   }
   // if match url path

package/dist/esm-node/libs/serverTiming.js

@@ -0,0 +1,17 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+const SERVER_TIMING = "Server-Timing";
+export class ServerTiming {
+  addServeTiming(name, dur, desc) {
+    const _name = `bd-${this.meta}-${name}`;
+    const serverTiming = this.res.getHeader(SERVER_TIMING) || this.res.getHeader(SERVER_TIMING.toLocaleLowerCase());
+    const value = `${_name};${desc ? `decs="${desc}";` : ""} dur=${dur}`;
+    this.res.setHeader(SERVER_TIMING, serverTiming ? `${serverTiming}, ${value}` : value);
+    return this;
+  }
+  constructor(res, meta) {
+    _define_property(this, "meta", void 0);
+    _define_property(this, "res", void 0);
+    this.meta = meta;
+    this.res = res;
+  }
+}

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

@@ -78,7 +78,8 @@ export class Server {
   }
   listen(options, listener) {
     const callback = () => {
-      listener === null || listener === void 0 ? void 0 : listener();
+      var _listener;
+      (_listener = listener) === null || _listener === void 0 ? void 0 : _listener();
     };
     if (typeof options === "object") {
       if (process.env.PORT) {
@@ -128,6 +129,7 @@ export class Server {
     });
   }
   initAppContext() {
+    var _appContext, _appContext1, _appContext2;
     const { options } = this;
     const { pwd: appDirectory, plugins = [], config, appContext } = options;
     const serverPlugins = plugins.map((p) => ({
@@ -135,9 +137,9 @@ export class Server {
     }));
     return {
       appDirectory,
-      apiDirectory: appContext === null || appContext === void 0 ? void 0 : appContext.apiDirectory,
-      lambdaDirectory: appContext === null || appContext === void 0 ? void 0 : appContext.lambdaDirectory,
-      sharedDirectory: (appContext === null || appContext === void 0 ? void 0 : appContext.sharedDirectory) || path.resolve(appDirectory, SHARED_DIR),
+      apiDirectory: (_appContext = appContext) === null || _appContext === void 0 ? void 0 : _appContext.apiDirectory,
+      lambdaDirectory: (_appContext1 = appContext) === null || _appContext1 === void 0 ? void 0 : _appContext1.lambdaDirectory,
+      sharedDirectory: ((_appContext2 = appContext) === null || _appContext2 === void 0 ? void 0 : _appContext2.sharedDirectory) || path.resolve(appDirectory, SHARED_DIR),
       distDirectory: path.join(appDirectory, config.output.path || "dist"),
       plugins: serverPlugins
     };

package/dist/esm-node/server/modernServer.js

@@ -2,10 +2,11 @@ import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { createServer } from "http";
 import path from "path";
 import { fs, isPromise, isWebOnly, mime, ROUTE_SPEC_FILE } from "@modern-js/utils";
+import { time } from "@modern-js/utils/universal/time";
 import { RouteMatchManager } from "../libs/route";
 import { createRenderHandler } from "../libs/render";
 import { createStaticFileHandler, faviconFallbackHandler } from "../libs/serveFile";
-import { createErrorDocument, createMiddlewareCollecter, getStaticReg, mergeExtension, noop, debug, isRedirect } from "../utils";
+import { createErrorDocument, createMiddlewareCollecter, getStaticReg, mergeExtension, noop, debug, isRedirect, bodyParser } from "../utils";
 import * as reader from "../libs/render/reader";
 import { createProxyHandler } from "../libs/proxy";
 import { createContext } from "../libs/context";
@@ -15,9 +16,9 @@ const SERVER_DIR = "./server";
 export class ModernServer {
   // server prepare
   async onInit(runner, app) {
-    var _conf_bff, _this_conf_server, _conf_security, _this_conf_output;
+    var _conf_bff, _app, _this_conf_output;
     this.runner = runner;
-    const { distDir, staticGenerate, conf, metaName } = this;
+    const { distDir, conf } = this;
     this.initReader();
     debug("final server conf", this.conf);
     this.proxyHandler = createProxyHandler((_conf_bff = conf.bff) === null || _conf_bff === void 0 ? void 0 : _conf_bff.proxy);
@@ -26,7 +27,7 @@ export class ModernServer {
         this.addHandler(handler);
       });
     }
-    app === null || app === void 0 ? void 0 : app.on("close", () => {
+    (_app = app) === null || _app === void 0 ? void 0 : _app.on("close", () => {
       this.reader.close();
     });
     const usageRoutes = this.filterRoutes(this.getRoutes());
@@ -34,20 +35,25 @@ export class ModernServer {
     this.warmupSSRBundle();
     await this.prepareFrameHandler();
     await this.prepareLoaderHandler(usageRoutes, distDir);
+    this.routeRenderHandler = this.getRenderHandler();
+    await this.setupBeforeProdMiddleware();
+    this.addHandler(this.setupStaticMiddleware((_this_conf_output = this.conf.output) === null || _this_conf_output === void 0 ? void 0 : _this_conf_output.assetPrefix));
+    this.addHandler(faviconFallbackHandler);
+    this.addHandler(this.routeHandler.bind(this));
+    this.compose();
+  }
+  getRenderHandler() {
+    var _this_conf_server, _conf_security;
+    const { distDir, staticGenerate, conf, metaName } = this;
     const ssrConfig = (_this_conf_server = this.conf.server) === null || _this_conf_server === void 0 ? void 0 : _this_conf_server.ssr;
     const forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
-    this.routeRenderHandler = createRenderHandler({
+    return createRenderHandler({
       distDir,
       staticGenerate,
       forceCSR,
       nonce: (_conf_security = conf.security) === null || _conf_security === void 0 ? void 0 : _conf_security.nonce,
       metaName
     });
-    await this.setupBeforeProdMiddleware();
-    this.addHandler(this.setupStaticMiddleware((_this_conf_output = this.conf.output) === null || _this_conf_output === void 0 ? void 0 : _this_conf_output.assetPrefix));
-    this.addHandler(faviconFallbackHandler);
-    this.addHandler(this.routeHandler.bind(this));
-    this.compose();
   }
   // server ready
   onRepack(_) {
@@ -59,7 +65,9 @@ export class ModernServer {
   async render(req, res, url) {
     req.logger = req.logger || this.logger;
     req.metrics = req.metrics || this.metrics;
-    const context = createContext(req, res);
+    const context = createContext(req, res, {
+      metaName: this.metaName
+    });
     const matched = this.router.match(url || context.path);
     if (!matched) {
       return null;
@@ -153,9 +161,10 @@ export class ModernServer {
     return handler;
   }
   async prepareAPIHandler(extension) {
+    var _bff, _bff1;
     const { workDir, runner, conf } = this;
     const { bff } = conf;
-    const prefix = (bff === null || bff === void 0 ? void 0 : bff.prefix) || "/api";
+    const prefix = ((_bff = bff) === null || _bff === void 0 ? void 0 : _bff.prefix) || "/api";
     const webOnly = await isWebOnly();
     if (webOnly && process.env.NODE_ENV === "development") {
       return (req, res) => {
@@ -167,7 +176,7 @@ export class ModernServer {
       pwd: workDir,
       config: extension,
       prefix: Array.isArray(prefix) ? prefix[0] : prefix,
-      httpMethodDecider: bff === null || bff === void 0 ? void 0 : bff.httpMethodDecider,
+      httpMethodDecider: (_bff1 = bff) === null || _bff1 === void 0 ? void 0 : _bff1.httpMethodDecider,
       render: this.render.bind(this)
     }, {
       onLast: () => null
@@ -259,23 +268,35 @@ export class ModernServer {
   /* —————————————————————— private function —————————————————————— */
   // handler route.json, include api / csr / ssr
   async routeHandler(context) {
-    const { res } = context;
+    const { res, req, reporter } = context;
     const matched = this.router.match(context.path);
     if (!matched) {
       this.render404(context);
       return;
     }
+    await reporter.init({
+      match: matched
+    });
+    const end = time();
+    res.on("finish", () => {
+      const cost = end();
+      reporter.reportTiming("server_handle_request", cost);
+    });
     let route = matched.generate(context.url);
     if (route.isApi) {
       await this.handleAPI(context);
       return;
     }
+    await bodyParser(req);
     if (route.entryName) {
       const afterMatchContext = createAfterMatchContext(context, route.entryName);
       if (this.runMode === RUN_MODE.FULL) {
+        const end2 = time();
         await this.runner.afterMatch(afterMatchContext, {
           onLast: noop
         });
+        const cost = end2();
+        reporter.reportTiming("server_hook_after_render", cost);
       }
       if (this.isSend(res)) {
         return;
@@ -297,7 +318,10 @@ export class ModernServer {
     if (this.frameWebHandler) {
       res.locals = res.locals || {};
       const middlewareContext = createMiddlewareContext(context);
+      const end2 = time();
       await this.frameWebHandler(middlewareContext);
+      const cost = end2();
+      reporter.reportTiming("server_middleware", cost);
       res.locals = {
         ...res.locals,
         ...middlewareContext.response.locals
@@ -319,9 +343,12 @@ export class ModernServer {
     if (route.entryName) {
       const afterRenderContext = createAfterRenderContext(context, response.toString());
       if (this.runMode === RUN_MODE.FULL) {
+        const end2 = time();
         await this.runner.afterRender(afterRenderContext, {
           onLast: noop
         });
+        const cost = end2();
+        reporter.reportTiming("server_hook_after_render", cost);
       }
       if (this.isSend(res)) {
         return;
@@ -434,6 +461,7 @@ export class ModernServer {
     context.res.end(createErrorDocument(status, text));
   }
   constructor({ pwd, config, routes, staticGenerate, logger, metrics, runMode, proxyTarget, appContext }) {
+    var _appContext;
     _define_property(this, "pwd", void 0);
     _define_property(this, "distDir", void 0);
     _define_property(this, "workDir", void 0);
@@ -448,13 +476,13 @@ export class ModernServer {
     _define_property(this, "reader", reader);
     _define_property(this, "proxyTarget", void 0);
     _define_property(this, "routeRenderHandler", void 0);
+    _define_property(this, "staticGenerate", void 0);
+    _define_property(this, "metaName", void 0);
     _define_property(this, "loaderHandler", null);
     _define_property(this, "frameWebHandler", null);
     _define_property(this, "frameAPIHandler", null);
     _define_property(this, "proxyHandler", null);
     _define_property(this, "_handler", void 0);
-    _define_property(this, "staticGenerate", void 0);
-    _define_property(this, "metaName", void 0);
     require("ignore-styles");
     this.pwd = pwd;
     this.distDir = path.resolve(pwd, config.output.path || "dist");
@@ -468,6 +496,6 @@ export class ModernServer {
     this.proxyTarget = proxyTarget;
     this.staticGenerate = staticGenerate || false;
     this.runMode = runMode || RUN_MODE.FULL;
-    this.metaName = appContext === null || appContext === void 0 ? void 0 : appContext.metaName;
+    this.metaName = (_appContext = appContext) === null || _appContext === void 0 ? void 0 : _appContext.metaName;
   }
 }

package/dist/esm-node/utils.js

@@ -119,3 +119,33 @@ export const isRedirect = (code) => {
     308
   ].includes(code);
 };
+function parseBodyTypes(headers, body) {
+  switch (headers["content-type"]) {
+    case "application/json":
+      return JSON.parse(body);
+    default:
+      return body;
+  }
+}
+const getRequestBody = (req) => new Promise((resolve, reject) => {
+  var _req;
+  if (((_req = req) === null || _req === void 0 ? void 0 : _req.method) && req.method.toLowerCase() !== "get") {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      resolve(parseBodyTypes(req.headers, body));
+    });
+    req.on("error", (err) => {
+      reject(err);
+    });
+  } else {
+    resolve(void 0);
+  }
+});
+export const bodyParser = async (req) => {
+  if (!req.body) {
+    req.body = await getRequestBody(req);
+  }
+};

package/dist/esm-node/workerServer.js

@@ -4,6 +4,7 @@ import { createAfterMatchContext, createAfterRenderContext, createMiddlewareCont
 import { Logger } from "./libs/logger";
 import { RouteMatchManager } from "./libs/route";
 import { metrics as defaultMetrics } from "./libs/metrics";
+import { defaultReporter } from "./libs/reporter";
 export class ReturnResponse {
   /**
   * Iterate a Object
@@ -69,7 +70,7 @@ export const createHandler = (manifest) => {
   const { pages, routes } = manifest;
   routeMgr.reset(routes);
   return async (options) => {
-    var _page_serverHooks, _page_serverHooks_afterMatch;
+    var _page_serverHooks_afterMatch, _page_serverHooks, _page;
     const { request, loadableStats, routeManifest } = options;
     const url = new URL(request.url);
     const pageMatch = routeMgr.match(url.pathname);
@@ -82,15 +83,16 @@ export const createHandler = (manifest) => {
       level: "warn"
     });
     const metrics = defaultMetrics;
-    const hookContext = createWorkerHookContext(request.url, logger, metrics);
+    const reporter = defaultReporter;
+    const hookContext = createWorkerHookContext(request.url, logger, metrics, reporter);
     const afterMatchHookContext = createAfterMatchContext(hookContext, entryName);
-    page === null || page === void 0 ? void 0 : (_page_serverHooks = page.serverHooks) === null || _page_serverHooks === void 0 ? void 0 : (_page_serverHooks_afterMatch = _page_serverHooks.afterMatch) === null || _page_serverHooks_afterMatch === void 0 ? void 0 : _page_serverHooks_afterMatch.call(_page_serverHooks, afterMatchHookContext, () => void 0);
+    (_page = page) === null || _page === void 0 ? void 0 : (_page_serverHooks = _page.serverHooks) === null || _page_serverHooks === void 0 ? void 0 : (_page_serverHooks_afterMatch = _page_serverHooks.afterMatch) === null || _page_serverHooks_afterMatch === void 0 ? void 0 : _page_serverHooks_afterMatch.call(_page_serverHooks, afterMatchHookContext, () => void 0);
     if (checkIsSent(hookContext)) {
       return new ReturnResponse(hookContext.res.body || "Unkown body", hookContext.res.status, hookContext.res.headers);
     }
     if (page.serverRender) {
       try {
-        var _page_serverHooks1, _page_serverHooks2, _page_serverHooks_afterRender;
+        var _page_serverHooks1, _page_serverHooks_afterRender, _page_serverHooks2;
         const middlewarsHookContext = createMiddlewareContext(hookContext);
         applyMiddlewares(middlewarsHookContext, (_page_serverHooks1 = page.serverHooks) === null || _page_serverHooks1 === void 0 ? void 0 : _page_serverHooks1.middleware);
         if (checkIsSent(hookContext)) {
@@ -118,9 +120,15 @@ export const createHandler = (manifest) => {
           template: page.template,
           entryName: page.entryName,
           logger,
+          reporter: defaultReporter,
           metrics,
           // FIXME: pass correctly req & res
           req: request,
+          serverTiming: {
+            addServeTiming() {
+              return this;
+            }
+          },
           res: responseLike
         };
         const body = await page.serverRender(serverRenderContext);
@@ -165,7 +173,7 @@ function createResponse(template) {
     return RESPONSE_NOTFOUND;
   }
 }
-function createWorkerHookContext(url, logger, metrics) {
+function createWorkerHookContext(url, logger, metrics, reporter) {
   const [res, req] = [
     {
       headers: new Headers(),
@@ -179,7 +187,8 @@ function createWorkerHookContext(url, logger, metrics) {
     res,
     req,
     logger,
-    metrics
+    metrics,
+    reporter
   };
 }
 function applyMiddlewares(ctx, middleware) {

package/dist/types/index.d.ts

@@ -6,5 +6,6 @@ export { ModernServer } from './server/modernServer';
 export { createProxyHandler } from './libs/proxy';
 export * from './type';
 export * from './constants';
+export { createRenderHandler } from './libs/render';
 declare const _default: (options: ModernServerOptions) => Promise<Server>;
 export default _default;

package/dist/types/libs/context/context.d.ts

@@ -2,11 +2,12 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node/http" />
-/// <reference types=".dts-temp/kKZBfG7unyISzN2HX-IzS/src/type" />
+/// <reference types=".dts-temp/rFczrZA4GO714tUiIeLuz/src/type" />
 import { IncomingMessage, ServerResponse } from 'http';
 import qs from 'querystring';
-import type { ModernServerContext as ModernServerContextInterface } from '@modern-js/types';
+import type { ModernServerContext as ModernServerContextInterface, Reporter as ModernServerReporter, ServerTiming as ModernServerTiming } from '@modern-js/types';
 export type ContextOptions = {
+  metaName?: string;
   etag?: boolean;
 };
 type ResponseBody = string | Buffer;
@@ -23,6 +24,8 @@ export declare class ModernServerContext implements ModernServerContextInterface
    * url params
    */
   params: Record<string, string>;
+  reporter: ModernServerReporter;
+  serverTiming: ModernServerTiming;
   get logger(): import("@modern-js/types").Logger;
   get metrics(): import("@modern-js/types").Metrics;
   serverData: Record<string, any>;

package/dist/types/libs/hook-api/index.worker.d.ts

@@ -1,4 +1,4 @@
-import { AfterMatchContext, AfterRenderContext, HookContext, Logger, Metrics, MiddlewareContext } from '@modern-js/types/server';
+import { AfterMatchContext, AfterRenderContext, HookContext, Logger, Metrics, MiddlewareContext, Reporter } from '@modern-js/types/server';
 export interface WorkerResponse {
   headers: Headers;
   status: number;
@@ -10,6 +10,7 @@ export interface WorkerServerContext {
   res: WorkerResponse;
   req: Request;
   logger: Logger;
+  reporter: Reporter;
   metrics: Metrics;
 }
 export declare const base: (context: WorkerServerContext) => HookContext;

package/dist/types/libs/render/index.d.ts

@@ -1,24 +1,19 @@
 import type { ModernServerContext } from '@modern-js/types';
 import { RenderResult, ServerHookRunner } from '../../type';
 import { ModernRoute } from '../route';
-export declare const createRenderHandler: ({
-  distDir,
-  staticGenerate,
-  forceCSR,
-  nonce,
-  metaName
-}: {
-  distDir: string;
-  staticGenerate: boolean;
-  forceCSR?: boolean | undefined;
-  nonce?: string | undefined;
-  metaName?: string | undefined;
-}) => ({
-  ctx,
-  route,
-  runner
-}: {
+import * as ssr from './ssr';
+export type RenderHandler = (options: {
   ctx: ModernServerContext;
   route: ModernRoute;
   runner: ServerHookRunner;
-}) => Promise<RenderResult | null>;
+}) => Promise<RenderResult | null>;
+type CreateRenderHandler = (ctx: {
+  distDir: string;
+  staticGenerate: boolean;
+  ssrRender?: typeof ssr.render;
+  forceCSR?: boolean;
+  nonce?: string;
+  metaName?: string;
+}) => RenderHandler;
+export declare const createRenderHandler: CreateRenderHandler;
+export {};

package/dist/types/libs/reporter.d.ts

@@ -0,0 +1,2 @@
+import { Reporter } from '@modern-js/types/server';
+export declare const defaultReporter: Reporter;

package/dist/types/libs/serverTiming.d.ts

@@ -0,0 +1,12 @@
+import { ServerTiming as IServerTiming } from '@modern-js/types';
+interface Res {
+  getHeader: (name: string) => number | string | string[] | undefined;
+  setHeader: (name: string, value: string) => void;
+}
+export declare class ServerTiming implements IServerTiming {
+  meta: string;
+  res: Res;
+  constructor(res: Res, meta: string);
+  addServeTiming(name: string, dur: number, desc?: string): this;
+}
+export {};

package/dist/types/server/modernServer.d.ts

@@ -2,10 +2,11 @@
 /// <reference types="node" />
 import { IncomingMessage, ServerResponse, Server } from 'http';
 import { Adapter, WebAdapter, APIServerStartInput, ServerOptions } from '@modern-js/server-core';
-import type { ModernServerContext, ServerRoute } from '@modern-js/types';
+import { type ModernServerContext, type ServerRoute } from '@modern-js/types';
 import type { ContextOptions } from '../libs/context';
 import { ModernServerOptions, NextFunction, ServerHookRunner, Metrics, Logger, ModernServerInterface, BuildOptions, ModernServerHandler } from '../type';
 import { RouteMatchManager, ModernRouteInterface, ModernRoute } from '../libs/route';
+import { RenderHandler } from '../libs/render';
 import { mergeExtension } from '../utils';
 import * as reader from '../libs/render/reader';
 type ModernServerAsyncHandler = (context: ModernServerContext, next: NextFunction) => Promise<void>;
@@ -23,14 +24,14 @@ export declare class ModernServer implements ModernServerInterface {
   protected readonly runMode: string;
   protected reader: typeof reader;
   protected readonly proxyTarget: ModernServerOptions['proxyTarget'];
-  private routeRenderHandler;
+  protected routeRenderHandler: RenderHandler;
+  protected readonly staticGenerate: boolean;
+  protected readonly metaName?: string;
   private loaderHandler;
   private frameWebHandler;
   private frameAPIHandler;
   private proxyHandler;
   private _handler;
-  private readonly staticGenerate;
-  private readonly metaName?;
   constructor({
     pwd,
     config,
@@ -43,6 +44,7 @@ export declare class ModernServer implements ModernServerInterface {
     appContext
   }: ModernServerOptions);
   onInit(runner: ServerHookRunner, app: Server): Promise<void>;
+  getRenderHandler(): RenderHandler;
   onRepack(_: BuildOptions): void;
   getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void | ServerResponse;
   render(req: IncomingMessage, res: ServerResponse, url?: string): Promise<string | import("stream").Readable | null>;

package/dist/types/type.d.ts

@@ -11,6 +11,7 @@ declare module 'http' {
   interface IncomingMessage {
     logger: Logger;
     metrics: Metrics;
+    body?: any;
   }
 }
 export type ModernServerOptions = {

package/dist/types/utils.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node/http" />
-/// <reference types=".dts-temp/kKZBfG7unyISzN2HX-IzS/src/type" />
+/// <reference types=".dts-temp/rFczrZA4GO714tUiIeLuz/src/type" />
 import { IncomingMessage } from 'http';
 import type { OutputNormalizedConfig, HtmlNormalizedConfig } from '@modern-js/server-core';
 export declare const debug: any;
@@ -21,4 +21,5 @@ export declare const createMiddlewareCollecter: () => {
 export declare const getStaticReg: (output?: OutputNormalizedConfig, html?: HtmlNormalizedConfig, prefix?: string) => RegExp;
 export declare const prepareFavicons: (favicon: string | undefined, faviconByEntries?: Record<string, string | undefined>) => string[];
 export declare const headersWithoutCookie: (headers: IncomingMessage['headers']) => import("http").IncomingHttpHeaders;
-export declare const isRedirect: (code: number) => boolean;
+export declare const isRedirect: (code: number) => boolean;
+export declare const bodyParser: (req: IncomingMessage) => Promise<void>;