@modern-js/server-core 2.48.4 → 2.48.5-alpha.1

package/dist/esm/base/index.js

@@ -0,0 +1,16 @@
+import { createErrorHtml } from "./utils";
+import { AGGRED_DIR } from "./constants";
+import { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy } from "./middlewares";
+import { createServerBase } from "./serverBase";
+export {
+  AGGRED_DIR,
+  bindRenderHandler,
+  createErrorHtml,
+  createServerBase,
+  favionFallbackMiddleware,
+  getRenderHandler,
+  injectLogger,
+  injectReporter,
+  logHandler,
+  processedBy
+};

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

@@ -0,0 +1,182 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _class_private_field_get } from "@swc/helpers/_/_class_private_field_get";
+import { _ as _class_private_field_init } from "@swc/helpers/_/_class_private_field_init";
+import { _ as _class_private_field_set } from "@swc/helpers/_/_class_private_field_set";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { getCookie } from "hono/cookie";
+import { getHost } from "../../utils";
+function createBaseHookContext(c) {
+  var logger = c.get("logger");
+  var metrics = c.get("metrics");
+  return {
+    request: new BaseHookRequest(c),
+    response: new BaseHookResponse(c),
+    logger,
+    metrics
+  };
+}
+var _headers = /* @__PURE__ */ new WeakMap();
+var BaseHookRequest = /* @__PURE__ */ function() {
+  "use strict";
+  function BaseHookRequest2(c) {
+    var _this = this;
+    _class_call_check(this, BaseHookRequest2);
+    _class_private_field_init(this, _headers, {
+      writable: true,
+      value: void 0
+    });
+    this.headersData = {};
+    this.c = c;
+    this.req = c.req;
+    var rawHeaders = this.req.raw.headers;
+    rawHeaders.forEach(function(value, key) {
+      _this.headersData[key] = value;
+    });
+    _class_private_field_set(this, _headers, new Proxy(this.headersData, {
+      get: function get(target, p) {
+        return target[p];
+      },
+      set: function set(target, p, newValue) {
+        target[p] = newValue;
+        rawHeaders.set(p, newValue);
+        return true;
+      }
+    }));
+  }
+  _create_class(BaseHookRequest2, [
+    {
+      key: "url",
+      get: function get() {
+        return this.req.path;
+      },
+      set: (
+        // TODO: remove next major version
+        function set(_u) {
+        }
+      )
+    },
+    {
+      key: "host",
+      get: function get() {
+        return getHost(this.req.raw);
+      },
+      set: (
+        // TODO: remove next major version
+        function set(_h) {
+        }
+      )
+    },
+    {
+      key: "pathname",
+      get: function get() {
+        return this.req.path;
+      },
+      set: (
+        // TODO: remove next major version
+        function set(_p) {
+        }
+      )
+    },
+    {
+      key: "query",
+      get: function get() {
+        return this.req.query();
+      },
+      set: (
+        // TODO: remove next major version
+        function set(_q) {
+        }
+      )
+    },
+    {
+      key: "headers",
+      get: function get() {
+        return _class_private_field_get(this, _headers);
+      },
+      set: (
+        // TODO: remove next major version
+        function set(_h) {
+        }
+      )
+    },
+    {
+      key: "cookies",
+      get: function get() {
+        var _this = this;
+        return {
+          // FIXME: ModernRequest Type Error
+          get: function(key) {
+            return getCookie(_this.c, key);
+          }
+        };
+      }
+    },
+    {
+      key: "cookie",
+      get: function get() {
+        return this.req.header("cookie");
+      },
+      set: (
+        // TODO: remove next major version
+        function set(_c) {
+        }
+      )
+    }
+  ]);
+  return BaseHookRequest2;
+}();
+var BaseHookResponse = /* @__PURE__ */ function() {
+  "use strict";
+  function BaseHookResponse2(c) {
+    _class_call_check(this, BaseHookResponse2);
+    this.private_overrided = false;
+    this.c = c;
+  }
+  var _proto = BaseHookResponse2.prototype;
+  _proto.get = function get(key) {
+    return this.c.res.headers.get(key);
+  };
+  _proto.set = function set(key, value) {
+    if ([
+      "set-cookie",
+      "Set-Cookie"
+    ].includes(key)) {
+      this.c.header(key, value.toString(), {
+        append: true
+      });
+    } else {
+      this.c.header(key, value.toString());
+    }
+  };
+  _proto.status = function status(code) {
+    this.c.status(code);
+  };
+  _proto.raw = function raw(body, options) {
+    this.c.res = this.c.newResponse(body, options);
+    this.private_overrided = true;
+  };
+  _create_class(BaseHookResponse2, [
+    {
+      key: "cookies",
+      get: function get() {
+        var _this = this;
+        var setCookie = function(key, value) {
+          _this.c.header("set-cookie", "".concat(key, "=").concat(value), {
+            append: true
+          });
+        };
+        var clearCookie = function() {
+          _this.c.header("set-cookie", void 0);
+        };
+        return {
+          set: setCookie,
+          clear: clearCookie
+        };
+      }
+    }
+  ]);
+  return BaseHookResponse2;
+}();
+export {
+  createBaseHookContext
+};

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

@@ -0,0 +1,68 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { RouterAPI } from "./routerApi";
+import { TemplateApi } from "./template";
+import { createBaseHookContext } from "./base";
+function getAfterMatchCtx(entryName, baseHookCtx) {
+  var afterMatchCtx = baseHookCtx;
+  afterMatchCtx.router = new RouterAPI(entryName);
+  return afterMatchCtx;
+}
+function getAfterRenderCtx(c, baseHookCtx, route) {
+  return _getAfterRenderCtx.apply(this, arguments);
+}
+function _getAfterRenderCtx() {
+  _getAfterRenderCtx = _async_to_generator(function(c, baseHookCtx, route) {
+    var afterRenderCtx, resBody;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          afterRenderCtx = baseHookCtx;
+          return [
+            4,
+            c.res.text()
+          ];
+        case 1:
+          resBody = _state.sent();
+          afterRenderCtx.template = new TemplateApi(resBody);
+          afterRenderCtx.route = route;
+          return [
+            2,
+            afterRenderCtx
+          ];
+      }
+    });
+  });
+  return _getAfterRenderCtx.apply(this, arguments);
+}
+function createCustomMiddlewaresCtx(c, locals) {
+  var _c_env_node, _c_env_node1;
+  var baseContext = createBaseHookContext(c);
+  var reporter = c.get("reporter");
+  return _object_spread_props(_object_spread({}, baseContext), {
+    reporter,
+    response: _object_spread_props(_object_spread({}, baseContext.response), {
+      locals
+    }),
+    source: {
+      req: (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req,
+      res: (_c_env_node1 = c.env.node) === null || _c_env_node1 === void 0 ? void 0 : _c_env_node1.res
+    }
+  });
+}
+function createAfterStreamingRenderContext(baseHookCtx, route) {
+  var streamingRenderCtx = baseHookCtx;
+  streamingRenderCtx.route = route;
+  return function(chunk) {
+    streamingRenderCtx.chunk = chunk;
+    return streamingRenderCtx;
+  };
+}
+export {
+  createAfterStreamingRenderContext,
+  createCustomMiddlewaresCtx,
+  getAfterMatchCtx,
+  getAfterRenderCtx
+};

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

@@ -0,0 +1,214 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { time } from "@modern-js/runtime-utils/time";
+import { transformResponse } from "../../utils";
+import { ServerReportTimings } from "../../constants";
+import { getAfterMatchCtx, getAfterRenderCtx, createCustomMiddlewaresCtx, createAfterStreamingRenderContext } from "./context";
+import { createBaseHookContext } from "./base";
+var noop = function() {
+};
+var isHtmlResponse = function(response) {
+  var contentType = response.headers.get("content-type");
+  return contentType === null || contentType === void 0 ? void 0 : contentType.includes("text/html");
+};
+var CustomServer = /* @__PURE__ */ function() {
+  "use strict";
+  function CustomServer2(runner, serverBase, pwd) {
+    _class_call_check(this, CustomServer2);
+    this.runner = runner;
+    this.serverBase = serverBase;
+    var webExtension = [];
+    this.serverMiddlewarePromise = runner.prepareWebServer({
+      pwd,
+      config: {
+        middleware: webExtension
+      }
+    }, {
+      onLast: function() {
+        return null;
+      }
+    });
+  }
+  var _proto = CustomServer2.prototype;
+  _proto.getHookMiddleware = function getHookMiddleware(entryName, routes) {
+    var _this = this;
+    return function() {
+      var _ref = _async_to_generator(function(c, next) {
+        var routeInfo, reporter, baseHookCtx, afterMatchCtx, getCost, cost, _afterMatchCtx_router, url, status, current, rewriteRoute, afterStreamingRenderContext, afterRenderCtx, getCost1, cost1, newBody;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              routeInfo = routes.find(function(route) {
+                return route.entryName === entryName;
+              });
+              reporter = c.get("reporter");
+              baseHookCtx = createBaseHookContext(c);
+              afterMatchCtx = getAfterMatchCtx(entryName, baseHookCtx);
+              getCost = time();
+              return [
+                4,
+                _this.runner.afterMatch(afterMatchCtx, {
+                  onLast: noop
+                })
+              ];
+            case 1:
+              _state.sent();
+              cost = getCost();
+              cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost));
+              _afterMatchCtx_router = afterMatchCtx.router, url = _afterMatchCtx_router.url, status = _afterMatchCtx_router.status;
+              if (url) {
+                return [
+                  2,
+                  c.redirect(url, status)
+                ];
+              }
+              current = afterMatchCtx.router.current;
+              if (current !== entryName) {
+                rewriteRoute = routes.find(function(route) {
+                  return route.entryName === current;
+                });
+                if (rewriteRoute) {
+                  return [
+                    2,
+                    _this.serverBase.request(rewriteRoute.urlPath)
+                  ];
+                }
+              }
+              if (c.finalized) {
+                return [
+                  2,
+                  void 0
+                ];
+              }
+              return [
+                4,
+                next()
+              ];
+            case 2:
+              _state.sent();
+              if (c.finalized && (!c.res.body || !isHtmlResponse(c.res))) {
+                return [
+                  2,
+                  void 0
+                ];
+              }
+              if (!routeInfo.isStream)
+                return [
+                  3,
+                  3
+                ];
+              afterStreamingRenderContext = createAfterStreamingRenderContext(baseHookCtx, routeInfo);
+              c.res = transformResponse(c.res, function(chunk) {
+                var context = afterStreamingRenderContext(chunk);
+                return _this.runner.afterStreamingRender(context, {
+                  onLast: function(param) {
+                    var _$chunk = param.chunk;
+                    return _$chunk;
+                  }
+                });
+              });
+              return [
+                3,
+                6
+              ];
+            case 3:
+              return [
+                4,
+                getAfterRenderCtx(c, baseHookCtx, routeInfo)
+              ];
+            case 4:
+              afterRenderCtx = _state.sent();
+              getCost1 = time();
+              return [
+                4,
+                _this.runner.afterRender(afterRenderCtx, {
+                  onLast: noop
+                })
+              ];
+            case 5:
+              _state.sent();
+              cost1 = getCost1();
+              cost1 && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_RENDER, cost1));
+              if (afterRenderCtx.response.private_overrided) {
+                return [
+                  2,
+                  void 0
+                ];
+              }
+              newBody = afterRenderCtx.template.get();
+              c.res = c.body(newBody);
+              _state.label = 6;
+            case 6:
+              return [
+                2
+              ];
+          }
+        });
+      });
+      return function(c, next) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+  };
+  _proto.getServerMiddleware = function getServerMiddleware() {
+    var _this = this;
+    return function() {
+      var _ref = _async_to_generator(function(c, next) {
+        var _c_env, serverMiddleware, reporter, locals, customMiddlewareCtx, getCost, cost;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              return [
+                4,
+                _this.serverMiddlewarePromise
+              ];
+            case 1:
+              serverMiddleware = _state.sent();
+              if (!serverMiddleware) {
+                return [
+                  2,
+                  next()
+                ];
+              }
+              reporter = c.get("reporter");
+              locals = {};
+              customMiddlewareCtx = createCustomMiddlewaresCtx(c, locals);
+              getCost = time();
+              return [
+                4,
+                serverMiddleware(customMiddlewareCtx)
+              ];
+            case 2:
+              _state.sent();
+              cost = getCost();
+              cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(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) {
+                return [
+                  2,
+                  void 0
+                ];
+              }
+              if (!c.finalized) {
+                return [
+                  2,
+                  next()
+                ];
+              }
+              return [
+                2
+              ];
+          }
+        });
+      });
+      return function(c, next) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+  };
+  return CustomServer2;
+}();
+export {
+  CustomServer
+};

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

@@ -0,0 +1,26 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+var RouterAPI = /* @__PURE__ */ function() {
+  "use strict";
+  function RouterAPI2(entryName) {
+    _class_call_check(this, RouterAPI2);
+    this.current = entryName;
+    this.status = 200;
+    this.url = "";
+  }
+  var _proto = RouterAPI2.prototype;
+  _proto.redirect = function redirect(url) {
+    var status = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 302;
+    this.url = url;
+    this.status = status;
+  };
+  _proto.rewrite = function rewrite(entryName) {
+    this.current = entryName;
+  };
+  _proto.use = function use(entryName) {
+    this.rewrite(entryName);
+  };
+  return RouterAPI2;
+}();
+export {
+  RouterAPI
+};

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

@@ -0,0 +1,47 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { REPLACE_REG } from "../../constants";
+var TemplateApi = /* @__PURE__ */ function() {
+  "use strict";
+  function TemplateApi2(body) {
+    _class_call_check(this, TemplateApi2);
+    this.body = body;
+  }
+  var _proto = TemplateApi2.prototype;
+  _proto.set = function set(content) {
+    this.body = content;
+  };
+  _proto.get = function get() {
+    return this.body;
+  };
+  _proto.prependHead = function prependHead(fragment) {
+    var head = REPLACE_REG.before.head;
+    this.replaceBody(new RegExp(head), function(beforeHead) {
+      return "".concat(beforeHead).concat(fragment);
+    });
+  };
+  _proto.appendHead = function appendHead(fragment) {
+    var head = REPLACE_REG.after.head;
+    this.replaceBody(head, function() {
+      return "".concat(fragment).concat(head);
+    });
+  };
+  _proto.prependBody = function prependBody(fragment) {
+    var body = REPLACE_REG.before.body;
+    this.replaceBody(new RegExp(body), function(beforeBody) {
+      return "".concat(beforeBody).concat(fragment);
+    });
+  };
+  _proto.appendBody = function appendBody(fragment) {
+    var body = REPLACE_REG.after.body;
+    this.replaceBody(body, function() {
+      return "".concat(fragment).concat(body);
+    });
+  };
+  _proto.replaceBody = function replaceBody(searchValue, replaceCb) {
+    this.body = this.body.replace(searchValue, replaceCb);
+  };
+  return TemplateApi2;
+}();
+export {
+  TemplateApi
+};

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

@@ -0,0 +1,28 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+var favionFallbackMiddleware = function() {
+  var _ref = _async_to_generator(function(c, next) {
+    return _ts_generator(this, function(_state) {
+      if (c.req.path === "/favicon.ico") {
+        return [
+          2,
+          c.body(null, 204)
+        ];
+      } else {
+        return [
+          2,
+          next()
+        ];
+      }
+      return [
+        2
+      ];
+    });
+  });
+  return function favionFallbackMiddleware2(c, next) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  favionFallbackMiddleware
+};

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

@@ -0,0 +1,27 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+var processedBy = function() {
+  var _ref = _async_to_generator(function(ctx, next) {
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            next()
+          ];
+        case 1:
+          _state.sent();
+          ctx.header("X-Processed-By", "Modern.js");
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function processedBy2(ctx, next) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  processedBy
+};

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

@@ -0,0 +1,5 @@
+export * from "./faviconFallback";
+export * from "./monitor";
+export * from "./renderHandler";
+export * from "./logger";
+export * from "./frameworkHeader";

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

@@ -0,0 +1,75 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { getPathname } from "../utils";
+var LogPrefix;
+(function(LogPrefix2) {
+  LogPrefix2["Outgoing"] = "-->";
+  LogPrefix2["Incoming"] = "<--";
+  LogPrefix2["Error"] = "xxx";
+})(LogPrefix || (LogPrefix = {}));
+var humanize = function(times) {
+  var delimiter = ",", separator = ".";
+  var orderTimes = times.map(function(v) {
+    return v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1".concat(delimiter));
+  });
+  return orderTimes.join(separator);
+};
+var time = function(start) {
+  var delta = Date.now() - start;
+  return humanize([
+    delta < 1e3 ? "".concat(delta, "ms") : "".concat(Math.round(delta / 1e3), "s")
+  ]);
+};
+var colorStatus = function(status) {
+  var out = {
+    7: "\x1B[35m".concat(status, "\x1B[0m"),
+    5: "\x1B[31m".concat(status, "\x1B[0m"),
+    4: "\x1B[33m".concat(status, "\x1B[0m"),
+    3: "\x1B[36m".concat(status, "\x1B[0m"),
+    2: "\x1B[32m".concat(status, "\x1B[0m"),
+    1: "\x1B[32m".concat(status, "\x1B[0m"),
+    0: "\x1B[33m".concat(status, "\x1B[0m")
+  };
+  var calculateStatus = Math.floor(status / 100);
+  return out[calculateStatus];
+};
+function log(fn, prefix, method, path) {
+  var status = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : 0, elapsed = arguments.length > 5 ? arguments[5] : void 0;
+  var out = prefix === "<--" ? "  ".concat(prefix, " ").concat(method, " ").concat(path) : "  ".concat(prefix, " ").concat(method, " ").concat(path, " ").concat(colorStatus(status), " ").concat(elapsed);
+  fn(out);
+}
+function logHandler() {
+  return function() {
+    var _logger = _async_to_generator(function(c, next) {
+      var method, _$logger, path, logFn, start;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            method = c.req.method;
+            _$logger = c.get("logger");
+            path = getPathname(c.req.raw);
+            logFn = _$logger.info;
+            log(logFn, "<--", method, path);
+            start = Date.now();
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            log(logFn, "-->", method, path, c.res.status, time(start));
+            return [
+              2
+            ];
+        }
+      });
+    });
+    function logger(c, next) {
+      return _logger.apply(this, arguments);
+    }
+    return logger;
+  }();
+}
+export {
+  logHandler
+};