@modern-js/server-core 2.49.4-alpha.1 → 2.49.4

package/dist/cjs/base/adapters/node/middlewares/serverPublic.js

@@ -47,6 +47,9 @@ function createPublicMiddleware({ pwd, routes }) {
         if (mimeType) {
           c.header("Content-Type", mimeType);
         }
+        Object.entries(route.responseHeaders || {}).forEach(([k, v]) => {
+          c.header(k, v);
+        });
         return c.body(data, 200);
       }
     }
@@ -55,7 +58,7 @@ function createPublicMiddleware({ pwd, routes }) {
 }
 function matchRoute(req, routes) {
   for (const route of routes.sort(import_utils.sortRoutes)) {
-    if (!route.isSSR && !route.isApi && route.entryPath.startsWith("public") && req.path.startsWith(route.urlPath)) {
+    if (!route.isSSR && route.entryPath.startsWith("public") && req.path.startsWith(route.urlPath)) {
       return route;
     }
   }

package/dist/cjs/base/adapters/node/middlewares/serverStatic.js

@@ -35,7 +35,6 @@ var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 var import_mime = require("hono/utils/mime");
 var import_fileReader = require("@modern-js/runtime-utils/fileReader");
-var import_utils2 = require("../../../utils");
 var import_serverPublic = require("./serverPublic");
 function createStaticMiddleware(options) {
   const { pwd, routes } = options;
@@ -69,7 +68,7 @@ function createStaticMiddleware(options) {
     if (hit) {
       const filepath = import_path.default.join(pwd, pathname.replace(prefix, () => ""));
       if (!await import_utils.fs.pathExists(filepath)) {
-        return c.html((0, import_utils2.createErrorHtml)(404), 404);
+        return next();
       }
       const mimeType = (0, import_mime.getMimeType)(filepath);
       if (mimeType) {

package/dist/cjs/base/adapters/node/node.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,6 +17,14 @@ 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 node_exports = {};
 __export(node_exports, {
@@ -112,9 +122,16 @@ const getRequestListener = (handler) => {
     }
   };
 };
-const createNodeServer = (requestHandler) => {
+const createNodeServer = async (requestHandler, httpsOptions) => {
   const requestListener = getRequestListener(requestHandler);
-  const nodeServer = (0, import_node_http.createServer)(requestListener);
+  let nodeServer;
+  if (httpsOptions) {
+    const { createServer } = await Promise.resolve().then(() => __toESM(require("node:https")));
+    nodeServer = createServer(httpsOptions, requestListener);
+  } else {
+    const { createServer } = await Promise.resolve().then(() => __toESM(require("node:http")));
+    nodeServer = createServer(requestListener);
+  }
   nodeServer.getRequestListener = () => requestListener;
   nodeServer.getRequestHandler = () => requestHandler;
   return nodeServer;

package/dist/cjs/base/adapters/node/polyfills/stream.js

@@ -29,17 +29,24 @@ async function writeReadableStreamToWritable(stream, writable) {
   const reader = stream.getReader();
   const flushable = writable;
   try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        writable.end();
-        break;
-      }
-      writable.write(value);
-      if (typeof flushable.flush === "function") {
-        flushable.flush();
-      }
-    }
+    await new Promise((resolve, reject) => {
+      writable.on("finish", resolve);
+      writable.on("error", reject);
+      const writeAndFlush = async () => {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            writable.end();
+            break;
+          }
+          writable.write(value);
+          if (typeof flushable.flush === "function") {
+            flushable.flush();
+          }
+        }
+      };
+      writeAndFlush().catch(reject);
+    });
   } catch (error) {
     writable.destroy(error);
     throw error;

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

@@ -26,12 +26,12 @@ var import_class_private_field_init = require("@swc/helpers/_/_class_private_fie
 var import_class_private_field_set = require("@swc/helpers/_/_class_private_field_set");
 var import_cookie = require("hono/cookie");
 var import_utils = require("../../utils");
-function createBaseHookContext(c) {
+function createBaseHookContext(c, resParams) {
   const logger = c.get("logger");
   const metrics = c.get("metrics");
   return {
     request: new BaseHookRequest(c),
-    response: new BaseHookResponse(c),
+    response: new BaseHookResponse(c, resParams),
     logger,
     metrics
   };
@@ -118,7 +118,7 @@ class BaseHookRequest {
     }));
   }
 }
-var _c1 = /* @__PURE__ */ new WeakMap();
+var _c1 = /* @__PURE__ */ new WeakMap(), _resArgs = /* @__PURE__ */ new WeakMap();
 class BaseHookResponse {
   get(key) {
     return (0, import_class_private_field_get._)(this, _c1).res.headers.get(key);
@@ -128,15 +128,20 @@ class BaseHookResponse {
       "set-cookie",
       "Set-Cookie"
     ].includes(key)) {
+      var _class_private_field_get1;
       (0, import_class_private_field_get._)(this, _c1).header(key, value.toString(), {
         append: true
       });
+      (_class_private_field_get1 = (0, import_class_private_field_get._)(this, _resArgs)) === null || _class_private_field_get1 === void 0 ? void 0 : _class_private_field_get1.headers.append(key, value.toString());
     } else {
+      var _class_private_field_get2;
       (0, import_class_private_field_get._)(this, _c1).header(key, value.toString());
+      (_class_private_field_get2 = (0, import_class_private_field_get._)(this, _resArgs)) === null || _class_private_field_get2 === void 0 ? void 0 : _class_private_field_get2.headers.set(key, value.toString());
     }
   }
   status(code) {
     (0, import_class_private_field_get._)(this, _c1).status(code);
+    (0, import_class_private_field_get._)(this, _resArgs) && ((0, import_class_private_field_get._)(this, _resArgs).status = code);
   }
   get cookies() {
     const setCookie = (key, value) => {
@@ -156,13 +161,18 @@ class BaseHookResponse {
     (0, import_class_private_field_get._)(this, _c1).res = (0, import_class_private_field_get._)(this, _c1).newResponse(body, options);
     this.private_overrided = true;
   }
-  constructor(c) {
+  constructor(c, resArgs) {
     (0, import_class_private_field_init._)(this, _c1, {
       writable: true,
       value: void 0
     });
+    (0, import_class_private_field_init._)(this, _resArgs, {
+      writable: true,
+      value: void 0
+    });
     this.private_overrided = false;
     (0, import_class_private_field_set._)(this, _c1, c);
+    (0, import_class_private_field_set._)(this, _resArgs, resArgs);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/base/middlewares/customServer/context.js

@@ -39,9 +39,9 @@ async function getAfterRenderCtx(c, baseHookCtx, route) {
   afterRenderCtx.route = route;
   return afterRenderCtx;
 }
-function createCustomMiddlewaresCtx(c, locals) {
+function createCustomMiddlewaresCtx(c, locals, resArgs) {
   var _c_env_node, _c_env_node1;
-  const baseContext = (0, import_base.createBaseHookContext)(c);
+  const baseContext = (0, import_base.createBaseHookContext)(c, resArgs);
   const reporter = c.get("reporter");
   const response = baseContext.response;
   response.locals = locals;

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

@@ -102,12 +102,18 @@ class CustomServer {
       }
       const reporter = c.get("reporter");
       const locals = {};
-      const customMiddlewareCtx = (0, import_context.createCustomMiddlewaresCtx)(c, locals);
+      const resArgs = {
+        headers: new Headers()
+      };
+      const customMiddlewareCtx = (0, import_context.createCustomMiddlewaresCtx)(c, locals, resArgs);
       const getCost = (0, import_time.time)();
       await serverMiddleware(customMiddlewareCtx);
       const cost = getCost();
       cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(import_constants.ServerReportTimings.SERVER_MIDDLEWARE, cost));
       c.set("locals", locals);
+      if (isRedirect(resArgs.headers, resArgs.status)) {
+        return c.redirect(resArgs.headers.get("Location") || "", resArgs.status || 302);
+      }
       if ((_c_env = c.env) === null || _c_env === void 0 ? void 0 : _c_env.node.res.headersSent) {
         return void 0;
       }
@@ -130,6 +136,14 @@ class CustomServer {
     });
   }
 }
+function isRedirect(headers, code) {
+  return [
+    301,
+    302,
+    307,
+    308
+  ].includes(code || 0) || headers.get("Location");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CustomServer

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

@@ -56,7 +56,12 @@ function createRenderHandler(render) {
       serverManifest,
       locals
     });
-    return res;
+    const { body, status, headers } = res;
+    const headersData = {};
+    headers.forEach((v, k) => {
+      headersData[k] = v;
+    });
+    return c.body(body, status, headersData);
   };
 }
 async function getRenderHandler(options, serverBase) {

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

@@ -22,13 +22,31 @@ __export(render_exports, {
 });
 module.exports = __toCommonJS(render_exports);
 var import_universal = require("@modern-js/utils/universal");
+var import_trie_router = require("hono/router/trie-router");
 var import_constants = require("../../../base/constants");
 var import_utils = require("../../utils");
 var import_dataHandler = require("./dataHandler");
 var import_ssrRender = require("./ssrRender");
+function getRouter(routes) {
+  const sorted = routes.sort(import_utils.sortRoutes);
+  const router = new import_trie_router.TrieRouter();
+  for (const route of sorted) {
+    const { urlPath: originUrlPath } = route;
+    const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
+    router.add("*", urlPath, route);
+  }
+  return router;
+}
+function matchRoute(router, request) {
+  const pathname = (0, import_utils.getPathname)(request);
+  const matched = router.match("*", pathname);
+  const result = matched[0][0];
+  return result || [];
+}
 async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce, onFallback: onFallbackFn }) {
+  const router = getRouter(routes);
   return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals, metrics }) => {
-    const routeInfo = matchRoute(req, routes);
+    const [routeInfo, params] = matchRoute(router, req);
     const onFallback = async (reason, error) => {
       return onFallbackFn === null || onFallbackFn === void 0 ? void 0 : onFallbackFn(reason, {
         logger,
@@ -69,6 +87,7 @@ async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, n
       nodeReq,
       reporter,
       serverRoutes: routes,
+      params,
       locals,
       serverManifest,
       metrics
@@ -92,7 +111,7 @@ async function renderHandler(request, options, mode, onError) {
   const serverData = {
     router: {
       baseUrl: options.routeInfo.urlPath,
-      params: {}
+      params: options.params
     }
   };
   let response;
@@ -106,17 +125,15 @@ async function renderHandler(request, options, mode, onError) {
   } else {
     response = csrRender(options.html);
   }
-  return (0, import_utils.transformResponse)(response, injectServerData(serverData));
-}
-function matchRoute(req, routes) {
-  const sorted = routes.sort(import_utils.sortRoutes);
-  for (const route of sorted) {
-    const pathname = (0, import_utils.getPathname)(req);
-    if (pathname.startsWith(route.urlPath)) {
-      return route;
-    }
+  const newRes = (0, import_utils.transformResponse)(response, injectServerData(serverData));
+  const { routeInfo } = options;
+  applyExtendHeaders(newRes, routeInfo);
+  return newRes;
+  function applyExtendHeaders(r, route) {
+    Object.entries(route.responseHeaders || {}).forEach(([k, v]) => {
+      r.headers.set(k, v);
+    });
   }
-  return void 0;
 }
 async function getRenderMode(req, framework, isSSR, forceCSR, nodeReq, onFallback) {
   const query = (0, import_utils.parseQuery)(req);

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

@@ -49,7 +49,7 @@ const defaultReporter = {
   reportWarn() {
   }
 };
-async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, metrics }) {
+async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics }) {
   var _serverManifest_renderBundles;
   const { entryName } = routeInfo;
   const loadableStats = serverManifest.loadableStats || {};
@@ -69,7 +69,7 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
   const ssrContext = {
     request: {
       baseUrl: routeInfo.urlPath,
-      params: {},
+      params,
       pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : (0, import_utils.getPathname)(request),
       host,
       query,

package/dist/esm/base/adapters/node/middlewares/serverPublic.js

@@ -1,4 +1,5 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { fileReader } from "@modern-js/runtime-utils/fileReader";
@@ -31,6 +32,10 @@ function createPublicMiddleware(param) {
               if (mimeType) {
                 c.header("Content-Type", mimeType);
               }
+              Object.entries(route.responseHeaders || {}).forEach(function(param2) {
+                var _param = _sliced_to_array(param2, 2), k = _param[0], v = _param[1];
+                c.header(k, v);
+              });
               return [
                 2,
                 c.body(data, 200)
@@ -60,7 +65,7 @@ function matchRoute(req, routes) {
   try {
     for (var _iterator = routes.sort(sortRoutes)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
       var route = _step.value;
-      if (!route.isSSR && !route.isApi && route.entryPath.startsWith("public") && req.path.startsWith(route.urlPath)) {
+      if (!route.isSSR && route.entryPath.startsWith("public") && req.path.startsWith(route.urlPath)) {
         return route;
       }
     }

package/dist/esm/base/adapters/node/middlewares/serverStatic.js

@@ -5,7 +5,6 @@ import path from "path";
 import { fs } from "@modern-js/utils";
 import { getMimeType } from "hono/utils/mime";
 import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { createErrorHtml } from "../../../utils";
 import { createPublicMiddleware } from "./serverPublic";
 function createStaticMiddleware(options) {
   var pwd = options.pwd, routes = options.routes;
@@ -54,7 +53,7 @@ function createStaticMiddleware(options) {
             if (!_state.sent()) {
               return [
                 2,
-                c.html(createErrorHtml(404), 404)
+                next()
               ];
             }
             mimeType = getMimeType(filepath);

package/dist/esm/base/adapters/node/node.js

@@ -2,7 +2,7 @@ import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { createServer, ServerResponse } from "node:http";
+import { ServerResponse } from "node:http";
 import { createReadableStreamFromReadable, writeReadableStreamToWritable } from "./polyfills/stream";
 import { installGlobals } from "./polyfills/install";
 installGlobals();
@@ -179,17 +179,56 @@ var getRequestListener = function(handler) {
     };
   }();
 };
-var createNodeServer = function(requestHandler) {
-  var requestListener = getRequestListener(requestHandler);
-  var nodeServer = createServer(requestListener);
-  nodeServer.getRequestListener = function() {
-    return requestListener;
-  };
-  nodeServer.getRequestHandler = function() {
-    return requestHandler;
+var createNodeServer = function() {
+  var _ref = _async_to_generator(function(requestHandler, httpsOptions) {
+    var requestListener, nodeServer, createServer, createServer1;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          requestListener = getRequestListener(requestHandler);
+          if (!httpsOptions)
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            import("node:https")
+          ];
+        case 1:
+          createServer = _state.sent().createServer;
+          nodeServer = createServer(httpsOptions, requestListener);
+          return [
+            3,
+            4
+          ];
+        case 2:
+          return [
+            4,
+            import("node:http")
+          ];
+        case 3:
+          createServer1 = _state.sent().createServer;
+          nodeServer = createServer1(requestListener);
+          _state.label = 4;
+        case 4:
+          nodeServer.getRequestListener = function() {
+            return requestListener;
+          };
+          nodeServer.getRequestHandler = function() {
+            return requestHandler;
+          };
+          return [
+            2,
+            nodeServer
+          ];
+      }
+    });
+  });
+  return function createNodeServer2(requestHandler, httpsOptions) {
+    return _ref.apply(this, arguments);
   };
-  return nodeServer;
-};
+}();
 export {
   createNodeServer,
   createWebRequest,

package/dist/esm/base/adapters/node/polyfills/stream.js

@@ -9,7 +9,7 @@ function writeReadableStreamToWritable(stream, writable) {
 }
 function _writeReadableStreamToWritable() {
   _writeReadableStreamToWritable = _async_to_generator(function(stream, writable) {
-    var reader, flushable, _ref, done, value, error;
+    var reader, flushable, error;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -19,48 +19,72 @@ function _writeReadableStreamToWritable() {
         case 1:
           _state.trys.push([
             1,
-            5,
+            3,
             ,
-            6
+            4
           ]);
-          _state.label = 2;
-        case 2:
-          if (false)
-            return [
-              3,
-              4
-            ];
           return [
             4,
-            reader.read()
+            new Promise(function(resolve, reject) {
+              writable.on("finish", resolve);
+              writable.on("error", reject);
+              var writeAndFlush = function() {
+                var _ref = _async_to_generator(function() {
+                  var _ref2, done, value;
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        if (false)
+                          return [
+                            3,
+                            2
+                          ];
+                        return [
+                          4,
+                          reader.read()
+                        ];
+                      case 1:
+                        _ref2 = _state2.sent(), done = _ref2.done, value = _ref2.value;
+                        if (done) {
+                          writable.end();
+                          return [
+                            3,
+                            2
+                          ];
+                        }
+                        writable.write(value);
+                        if (typeof flushable.flush === "function") {
+                          flushable.flush();
+                        }
+                        return [
+                          3,
+                          0
+                        ];
+                      case 2:
+                        return [
+                          2
+                        ];
+                    }
+                  });
+                });
+                return function writeAndFlush2() {
+                  return _ref.apply(this, arguments);
+                };
+              }();
+              writeAndFlush().catch(reject);
+            })
           ];
-        case 3:
-          _ref = _state.sent(), done = _ref.done, value = _ref.value;
-          if (done) {
-            writable.end();
-            return [
-              3,
-              4
-            ];
-          }
-          writable.write(value);
-          if (typeof flushable.flush === "function") {
-            flushable.flush();
-          }
-          return [
-            3,
-            2
-          ];
-        case 4:
+        case 2:
+          _state.sent();
           return [
             3,
-            6
+            4
           ];
-        case 5:
+        case 3:
           error = _state.sent();
           writable.destroy(error);
           throw error;
-        case 6:
+        case 4:
           return [
             2
           ];

package/dist/esm/base/middlewares/customServer/base.js

@@ -5,12 +5,12 @@ import { _ as _class_private_field_set } from "@swc/helpers/_/_class_private_fie
 import { _ as _create_class } from "@swc/helpers/_/_create_class";
 import { getCookie } from "hono/cookie";
 import { getHost } from "../../utils";
-function createBaseHookContext(c) {
+function createBaseHookContext(c, resParams) {
   var logger = c.get("logger");
   var metrics = c.get("metrics");
   return {
     request: new BaseHookRequest(c),
-    response: new BaseHookResponse(c),
+    response: new BaseHookResponse(c, resParams),
     logger,
     metrics
   };
@@ -137,17 +137,22 @@ var BaseHookRequest = /* @__PURE__ */ function() {
   ]);
   return BaseHookRequest2;
 }();
-var _c1 = /* @__PURE__ */ new WeakMap();
+var _c1 = /* @__PURE__ */ new WeakMap(), _resArgs = /* @__PURE__ */ new WeakMap();
 var BaseHookResponse = /* @__PURE__ */ function() {
   "use strict";
-  function BaseHookResponse2(c) {
+  function BaseHookResponse2(c, resArgs) {
     _class_call_check(this, BaseHookResponse2);
     _class_private_field_init(this, _c1, {
       writable: true,
       value: void 0
     });
+    _class_private_field_init(this, _resArgs, {
+      writable: true,
+      value: void 0
+    });
     this.private_overrided = false;
     _class_private_field_set(this, _c1, c);
+    _class_private_field_set(this, _resArgs, resArgs);
   }
   var _proto = BaseHookResponse2.prototype;
   _proto.get = function get(key) {
@@ -158,15 +163,20 @@ var BaseHookResponse = /* @__PURE__ */ function() {
       "set-cookie",
       "Set-Cookie"
     ].includes(key)) {
+      var _$_class_private_field_get;
       _class_private_field_get(this, _c1).header(key, value.toString(), {
         append: true
       });
+      (_$_class_private_field_get = _class_private_field_get(this, _resArgs)) === null || _$_class_private_field_get === void 0 ? void 0 : _$_class_private_field_get.headers.append(key, value.toString());
     } else {
+      var _$_class_private_field_get1;
       _class_private_field_get(this, _c1).header(key, value.toString());
+      (_$_class_private_field_get1 = _class_private_field_get(this, _resArgs)) === null || _$_class_private_field_get1 === void 0 ? void 0 : _$_class_private_field_get1.headers.set(key, value.toString());
     }
   };
   _proto.status = function status(code) {
     _class_private_field_get(this, _c1).status(code);
+    _class_private_field_get(this, _resArgs) && (_class_private_field_get(this, _resArgs).status = code);
   };
   _proto.raw = function raw(body, options) {
     _class_private_field_get(this, _c1).res = _class_private_field_get(this, _c1).newResponse(body, options);

package/dist/esm/base/middlewares/customServer/context.js

@@ -37,9 +37,9 @@ function _getAfterRenderCtx() {
   });
   return _getAfterRenderCtx.apply(this, arguments);
 }
-function createCustomMiddlewaresCtx(c, locals) {
+function createCustomMiddlewaresCtx(c, locals, resArgs) {
   var _c_env_node, _c_env_node1;
-  var baseContext = createBaseHookContext(c);
+  var baseContext = createBaseHookContext(c, resArgs);
   var reporter = c.get("reporter");
   var response = baseContext.response;
   response.locals = locals;