@modern-js/server-core 2.49.4-alpha.2 → 2.49.5-alpha.0

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/index.js

@@ -24,6 +24,7 @@ __export(base_exports, {
   createErrorHtml: () => import_utils.createErrorHtml,
   createServerBase: () => import_serverBase.createServerBase,
   favionFallbackMiddleware: () => import_middlewares.favionFallbackMiddleware,
+  getLoaderCtx: () => import_middlewares.getLoaderCtx,
   getRenderHandler: () => import_middlewares.getRenderHandler,
   injectLogger: () => import_middlewares.injectLogger,
   injectReporter: () => import_middlewares.injectReporter,
@@ -44,6 +45,7 @@ var import_serverBase = require("./serverBase");
   createErrorHtml,
   createServerBase,
   favionFallbackMiddleware,
+  getLoaderCtx,
   getRenderHandler,
   injectLogger,
   injectReporter,

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

@@ -18,14 +18,17 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var customServer_exports = {};
 __export(customServer_exports, {
-  CustomServer: () => CustomServer
+  CustomServer: () => CustomServer,
+  getLoaderCtx: () => import_loader2.getLoaderCtx
 });
 module.exports = __toCommonJS(customServer_exports);
 var import_time = require("@modern-js/runtime-utils/time");
 var import_utils = require("../../utils");
 var import_constants = require("../../constants");
+var import_loader = require("./loader");
 var import_context = require("./context");
 var import_base = require("./base");
+var import_loader2 = require("./loader");
 const noop = () => {
 };
 const isHtmlResponse = (response) => {
@@ -93,22 +96,31 @@ class CustomServer {
       }
     };
   }
-  getServerMiddleware() {
+  async getServerMiddleware() {
+    const serverMiddleware = await this.serverMiddlewarePromise;
+    if (!serverMiddleware) {
+      return;
+    }
+    if (Array.isArray(serverMiddleware)) {
+      return getUnstableMiddlewares(serverMiddleware);
+    }
     return async (c, next) => {
-      var _c_env;
-      const serverMiddleware = await this.serverMiddlewarePromise;
-      if (!serverMiddleware) {
-        return next();
-      }
+      var _c_env_node_res, _c_env_node, _c_env;
       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 ((_c_env = c.env) === null || _c_env === void 0 ? void 0 : _c_env.node.res.headersSent) {
+      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 = _c_env.node) === null || _c_env_node === void 0 ? void 0 : (_c_env_node_res = _c_env_node.res) === null || _c_env_node_res === void 0 ? void 0 : _c_env_node_res.headersSent) {
         return void 0;
       }
       if (!c.finalized) {
@@ -126,11 +138,53 @@ class CustomServer {
         middleware: webExtension
       }
     }, {
-      onLast: () => null
+      onLast: () => []
     });
   }
 }
+function isRedirect(headers, code) {
+  return [
+    301,
+    302,
+    307,
+    308
+  ].includes(code || 0) || headers.get("Location");
+}
+function getUnstableMiddlewares(serverMiddleware) {
+  return serverMiddleware.map((middleware) => {
+    return async (c, next) => {
+      const context = createMiddlewareContextFromHono(c);
+      return middleware(context, next);
+    };
+  });
+}
+function createMiddlewareContextFromHono(c) {
+  const loaderContext = (0, import_loader.getLoaderCtx)(c);
+  return {
+    get request() {
+      return c.req.raw;
+    },
+    get response() {
+      return c.res;
+    },
+    set response(newRes) {
+      c.res = newRes;
+    },
+    get(key) {
+      return loaderContext.get(key);
+    },
+    set(key, value) {
+      return loaderContext.set(key, value);
+    },
+    status: c.status.bind(c),
+    header: c.header.bind(c),
+    body: c.body.bind(c),
+    html: c.html.bind(c),
+    redirect: c.redirect.bind(c)
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CustomServer
+  CustomServer,
+  getLoaderCtx
 });

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

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 loader_exports = {};
+__export(loader_exports, {
+  getLoaderCtx: () => getLoaderCtx
+});
+module.exports = __toCommonJS(loader_exports);
+function getLoaderCtx(c) {
+  const loaderContext = c.get("loaderContext");
+  if (loaderContext) {
+    return loaderContext;
+  } else {
+    const loaderContext2 = /* @__PURE__ */ new Map();
+    c.set("loaderContext", loaderContext2);
+    return loaderContext2;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLoaderCtx
+});

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

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -14,14 +18,19 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var middlewares_exports = {};
+__export(middlewares_exports, {
+  getLoaderCtx: () => import_customServer.getLoaderCtx
+});
 module.exports = __toCommonJS(middlewares_exports);
 __reExport(middlewares_exports, require("./faviconFallback"), module.exports);
 __reExport(middlewares_exports, require("./monitor"), module.exports);
 __reExport(middlewares_exports, require("./renderHandler"), module.exports);
 __reExport(middlewares_exports, require("./logger"), module.exports);
 __reExport(middlewares_exports, require("./frameworkHeader"), module.exports);
+var import_customServer = require("./customServer");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  getLoaderCtx,
   ...require("./faviconFallback"),
   ...require("./monitor"),
   ...require("./renderHandler"),

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

@@ -45,6 +45,7 @@ function createRenderHandler(render) {
     const serverManifest = c.get("serverManifest") || {};
     const locals = c.get("locals");
     const metrics = c.get("metrics");
+    const loaderContext = (0, import_customServer.getLoaderCtx)(c);
     const request = c.req.raw;
     const nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
     const res = await render(request, {
@@ -54,9 +55,15 @@ function createRenderHandler(render) {
       templates,
       metrics,
       serverManifest,
+      loaderContext,
       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) {
@@ -103,8 +110,14 @@ async function bindRenderHandler(server, options) {
       const customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
       server.use(urlPath, (0, import_monitor.initReporter)(entryName));
       !disableCustomHook && server.use(urlPath, customServerHookMiddleware);
-      const customServerMiddleware = customServer.getServerMiddleware();
-      server.use(urlPath, customServerMiddleware);
+      const customServerMiddleware = await customServer.getServerMiddleware();
+      if (customServerMiddleware) {
+        if (Array.isArray(customServerMiddleware)) {
+          server.use(urlPath, ...customServerMiddleware);
+        } else {
+          server.use(urlPath, customServerMiddleware);
+        }
+      }
       render && server.all(urlPath, createRenderHandler(render));
     }
   }

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

@@ -23,8 +23,8 @@ __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_constants = require("../../../base/constants");
 var import_dataHandler = require("./dataHandler");
 var import_ssrRender = require("./ssrRender");
 function getRouter(routes) {
@@ -45,7 +45,7 @@ function matchRoute(router, request) {
 }
 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 }) => {
+  return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals, metrics, loaderContext }) => {
     const [routeInfo, params] = matchRoute(router, req);
     const onFallback = async (reason, error) => {
       return onFallbackFn === null || onFallbackFn === void 0 ? void 0 : onFallbackFn(reason, {
@@ -90,7 +90,8 @@ async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, n
       params,
       locals,
       serverManifest,
-      metrics
+      metrics,
+      loaderContext: loaderContext || /* @__PURE__ */ new Map()
     };
     switch (renderMode) {
       case "data":

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

@@ -35,8 +35,8 @@ module.exports = __toCommonJS(ssrCache_exports);
 var import_stream = require("stream");
 var import_utils = require("@modern-js/utils");
 var import_storer = require("@modern-js/runtime-utils/storer");
-var import_stream2 = require("../../adapters/node/polyfills/stream");
 var import_utils2 = require("../../utils");
+var import_stream2 = require("../../adapters/node/polyfills/stream");
 class CacheManager {
   async getCacheResult(req, cacheControl, render, ssrContext) {
     const key = this.computedKey(req, cacheControl);

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, params, metrics }) {
+async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext }) {
   var _serverManifest_renderBundles;
   const { entryName } = routeInfo;
   const loadableStats = serverManifest.loadableStats || {};
@@ -88,6 +88,7 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
     redirection: {},
     template: html,
     loadableStats,
+    loaderContext,
     routeManifest,
     entryName,
     staticGenerate,

package/dist/cjs/base/utils/index.js

@@ -16,19 +16,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 module.exports = __toCommonJS(utils_exports);
 __reExport(utils_exports, require("./env"), module.exports);
-__reExport(utils_exports, require("./request"), module.exports);
 __reExport(utils_exports, require("./transformStream"), module.exports);
 __reExport(utils_exports, require("./middlewareCollector"), module.exports);
 __reExport(utils_exports, require("./error"), module.exports);
 __reExport(utils_exports, require("./warmup"), module.exports);
 __reExport(utils_exports, require("./entry"), module.exports);
+__reExport(utils_exports, require("./request"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./env"),
-  ...require("./request"),
   ...require("./transformStream"),
   ...require("./middlewareCollector"),
   ...require("./error"),
   ...require("./warmup"),
-  ...require("./entry")
+  ...require("./entry"),
+  ...require("./request")
 });

package/dist/cjs/base/utils/request.js

@@ -20,18 +20,19 @@ var request_exports = {};
 __export(request_exports, {
   getHost: () => getHost,
   getPathname: () => getPathname,
+  parseCookie: () => parseCookie,
   parseHeaders: () => parseHeaders,
   parseQuery: () => parseQuery
 });
 module.exports = __toCommonJS(request_exports);
-function parseQuery(request) {
-  const { url } = request;
-  const q = url.split("?")[1];
+function parseQuery(req) {
   const query = {};
+  const { url } = req;
+  const q = url.split("?")[1];
   if (q) {
-    q.split("&").forEach((item) => {
-      const [key, value] = item.split("=");
-      query[key] = value;
+    const search = new URLSearchParams(q);
+    search.forEach((v, k) => {
+      query[k] = v;
     });
   }
   return query;
@@ -56,10 +57,22 @@ function getHost(request) {
   host = (host === null || host === void 0 ? void 0 : host.split(/\s*,\s*/, 1)[0]) || "undefined";
   return host;
 }
+function parseCookie(req) {
+  const _cookie = req.headers.get("Cookie");
+  const cookie = {};
+  _cookie === null || _cookie === void 0 ? void 0 : _cookie.trim().split(";").forEach((item) => {
+    const [k, v] = item.trim().split("=");
+    if (k) {
+      cookie[k] = v;
+    }
+  });
+  return cookie;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getHost,
   getPathname,
+  parseCookie,
   parseHeaders,
   parseQuery
 });

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,