@modern-js/server-core 2.48.2 → 2.48.3-alpha.0

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

@@ -0,0 +1,126 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { getCookie } from "hono/cookie";
+import { getHost } from "../../utils";
+function createBaseHookContext(c, logger, metrics) {
+  return {
+    request: new BaseHookRequest(c),
+    response: new BaseHookResponse(c),
+    logger,
+    metrics
+  };
+}
+var BaseHookRequest = /* @__PURE__ */ function() {
+  "use strict";
+  function BaseHookRequest2(c) {
+    _class_call_check(this, BaseHookRequest2);
+    this.c = c;
+    this.req = c.req;
+  }
+  _create_class(BaseHookRequest2, [
+    {
+      key: "url",
+      get: function get() {
+        return this.req.url;
+      }
+    },
+    {
+      key: "host",
+      get: function get() {
+        return getHost(this.req.raw);
+      }
+    },
+    {
+      key: "pathname",
+      get: function get() {
+        return this.req.path;
+      }
+    },
+    {
+      key: "query",
+      get: function get() {
+        return this.req.query();
+      }
+    },
+    {
+      key: "headers",
+      get: function get() {
+        return this.req.header();
+      }
+    },
+    {
+      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");
+      }
+    }
+  ]);
+  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,70 @@
+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 createAfterMatchCtx(c, entryName, logger, metrics) {
+  var baseContext = createBaseHookContext(c, logger, metrics);
+  return _object_spread_props(_object_spread({}, baseContext), {
+    router: new RouterAPI(entryName)
+  });
+}
+function createAfterRenderCtx(c, logger, metrics) {
+  return _createAfterRenderCtx.apply(this, arguments);
+}
+function _createAfterRenderCtx() {
+  _createAfterRenderCtx = _async_to_generator(function(c, logger, metrics) {
+    var baseContext, resBody;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          baseContext = createBaseHookContext(c, logger, metrics);
+          return [
+            4,
+            c.res.text()
+          ];
+        case 1:
+          resBody = _state.sent();
+          return [
+            2,
+            _object_spread_props(_object_spread({}, baseContext), {
+              template: new TemplateApi(resBody)
+            })
+          ];
+      }
+    });
+  });
+  return _createAfterRenderCtx.apply(this, arguments);
+}
+function createCustomMiddlewaresCtx(c, logger, metrics) {
+  var _c_env_node, _c_env_node1;
+  var baseContext = createBaseHookContext(c, logger, metrics);
+  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(c, logger, route, metrics) {
+  var baseContext = createBaseHookContext(c, logger, metrics);
+  return function(chunk) {
+    return _object_spread_props(_object_spread({}, baseContext), {
+      route,
+      chunk
+    });
+  };
+}
+export {
+  createAfterMatchCtx,
+  createAfterRenderCtx,
+  createAfterStreamingRenderContext,
+  createCustomMiddlewaresCtx
+};

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

@@ -0,0 +1,208 @@
+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 { createAfterMatchCtx, createAfterRenderCtx, createCustomMiddlewaresCtx, createAfterStreamingRenderContext } from "./context";
+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, logger, reporter, metrics, 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;
+              });
+              logger = c.get("logger");
+              reporter = c.get("reporter");
+              metrics = c.get("metrics");
+              afterMatchCtx = createAfterMatchCtx(c, entryName, logger, metrics);
+              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(c, logger, routeInfo, metrics);
+              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,
+                createAfterRenderCtx(c, logger, metrics)
+              ];
+            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 serverMiddleware, logger, reporter, metrics, 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()
+                ];
+              }
+              logger = c.get("logger");
+              reporter = c.get("reporter");
+              metrics = c.get("metrics");
+              customMiddlewareCtx = createCustomMiddlewaresCtx(c, logger, metrics);
+              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));
+              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/index.js

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

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

@@ -0,0 +1,157 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { time } from "@modern-js/runtime-utils/time";
+import { ServerReportTimings } from "../constants";
+var defaultReporter = {
+  init: function init() {
+  },
+  reportError: function reportError() {
+  },
+  reportTiming: function reportTiming() {
+  },
+  reportInfo: function reportInfo() {
+  },
+  reportWarn: function reportWarn() {
+  }
+};
+function injectReporter() {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var reporter;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            reporter = c.get("reporter");
+            if (!reporter) {
+              c.set("reporter", defaultReporter);
+            }
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+function initReporter(entryName) {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var reporter, getCost, cost;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            reporter = c.get("reporter");
+            if (!!reporter)
+              return [
+                3,
+                2
+              ];
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+          case 2:
+            return [
+              4,
+              reporter.init({
+                entryName
+              })
+            ];
+          case 3:
+            _state.sent();
+            getCost = time();
+            return [
+              4,
+              next()
+            ];
+          case 4:
+            _state.sent();
+            cost = getCost();
+            reporter.reportTiming(ServerReportTimings.SERVER_HANDLE_REQUEST, cost);
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+function injectLogger(inputLogger) {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var logger;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            logger = c.get("logger");
+            if (!logger && inputLogger) {
+              c.set("logger", inputLogger);
+            }
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+function injectMetrics(inputMetrics) {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var metrics;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            metrics = c.get("metrics");
+            if (!metrics) {
+              c.set("metrics", inputMetrics);
+            }
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+export {
+  initReporter,
+  injectLogger,
+  injectMetrics,
+  injectReporter
+};