@modern-js/server-core 2.48.6 → 2.49.1-alpha.0

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

@@ -0,0 +1,306 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+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 { Readable } from "stream";
+import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
+import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
+import { createReadableStreamFromReadable } from "../../adapters/node/polyfills/stream";
+import { createTransformStream, getPathname } from "../../utils";
+var CacheManager = /* @__PURE__ */ function() {
+  "use strict";
+  function CacheManager2(container) {
+    _class_call_check(this, CacheManager2);
+    this.container = container;
+  }
+  var _proto = CacheManager2.prototype;
+  _proto.getCacheResult = function getCacheResult(req, cacheControl, render, ssrContext) {
+    var _this = this;
+    return _async_to_generator(function() {
+      var key, value, maxAge, staleWhileRevalidate, ttl, cache, interval;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            key = _this.computedKey(req, cacheControl);
+            return [
+              4,
+              _this.container.get(key)
+            ];
+          case 1:
+            value = _state.sent();
+            maxAge = cacheControl.maxAge, staleWhileRevalidate = cacheControl.staleWhileRevalidate;
+            ttl = maxAge + staleWhileRevalidate;
+            if (value) {
+              cache = JSON.parse(value);
+              interval = Date.now() - cache.cursor;
+              if (interval <= maxAge) {
+                return [
+                  2,
+                  {
+                    data: cache.val,
+                    status: "hit"
+                  }
+                ];
+              } else if (interval <= staleWhileRevalidate + maxAge) {
+                _this.processCache(key, render, ssrContext, ttl);
+                return [
+                  2,
+                  {
+                    data: cache.val,
+                    status: "stale"
+                  }
+                ];
+              } else {
+                return [
+                  2,
+                  _this.processCache(key, render, ssrContext, ttl, "expired")
+                ];
+              }
+            } else {
+              return [
+                2,
+                _this.processCache(key, render, ssrContext, ttl, "miss")
+              ];
+            }
+            return [
+              2
+            ];
+        }
+      });
+    })();
+  };
+  _proto.processCache = function processCache(key, render, ssrContext, ttl, status) {
+    var _this = this;
+    return _async_to_generator(function() {
+      var renderResult, current, cache, body, html, stream;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              render(ssrContext)
+            ];
+          case 1:
+            renderResult = _state.sent();
+            if (!!renderResult)
+              return [
+                3,
+                2
+              ];
+            return [
+              2,
+              {
+                data: ""
+              }
+            ];
+          case 2:
+            if (!(typeof renderResult === "string"))
+              return [
+                3,
+                4
+              ];
+            current = Date.now();
+            cache = {
+              val: renderResult,
+              cursor: current
+            };
+            return [
+              4,
+              _this.container.set(key, JSON.stringify(cache), {
+                ttl
+              })
+            ];
+          case 3:
+            _state.sent();
+            return [
+              2,
+              {
+                data: renderResult,
+                status
+              }
+            ];
+          case 4:
+            body = // TODO: remove node:stream, move it to ssr entry.
+            _instanceof(renderResult, Readable) ? createReadableStreamFromReadable(renderResult) : renderResult;
+            html = "";
+            stream = createTransformStream(function(chunk) {
+              html += chunk;
+              return chunk;
+            });
+            stream.readable.getReader().closed.then(function() {
+              var current2 = Date.now();
+              var cache2 = {
+                val: html,
+                cursor: current2
+              };
+              _this.container.set(key, JSON.stringify(cache2), {
+                ttl
+              });
+            });
+            body.pipeThrough(stream);
+            return [
+              2,
+              {
+                data: stream.readable,
+                status
+              }
+            ];
+          case 5:
+            return [
+              2
+            ];
+        }
+      });
+    })();
+  };
+  _proto.computedKey = function computedKey(req, cacheControl) {
+    var pathname = getPathname(req);
+    var customKey = cacheControl.customKey;
+    var defaultKey = pathname.replace(/.+\/+$/, "");
+    if (customKey) {
+      if (typeof customKey === "string") {
+        return customKey;
+      } else {
+        return customKey(defaultKey);
+      }
+    } else {
+      return defaultKey;
+    }
+  };
+  return CacheManager2;
+}();
+var CACHE_FILENAME = "cache";
+var ServerCache = /* @__PURE__ */ function() {
+  "use strict";
+  function ServerCache2() {
+    _class_call_check(this, ServerCache2);
+  }
+  var _proto = ServerCache2.prototype;
+  _proto.loadCacheMod = function loadCacheMod() {
+    var pwd = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : process.cwd();
+    var _this = this;
+    return _async_to_generator(function() {
+      var path, serverCacheFilepath, mod, cacheStorage;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              import("path").catch(function() {
+                return {};
+              })
+            ];
+          case 1:
+            path = _state.sent();
+            serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
+            mod = requireExistModule(serverCacheFilepath, {
+              interop: false
+            });
+            _this.cacheOption = mod === null || mod === void 0 ? void 0 : mod.cacheOption;
+            if (_this.cacheOption && !(mod === null || mod === void 0 ? void 0 : mod.customContainer)) {
+              cacheStorage = createMemoryStorage("__ssr__cache");
+              _this.customContainer = cacheStorage;
+            } else {
+              _this.customContainer = mod === null || mod === void 0 ? void 0 : mod.customContainer;
+            }
+            if (_this.customContainer) {
+              _this.cacheManger = new CacheManager(_this.customContainer);
+            }
+            return [
+              2
+            ];
+        }
+      });
+    })();
+  };
+  _proto.matchCacheControl = function matchCacheControl(req) {
+    var cacheOption = this.cacheOption;
+    if (!cacheOption || !req) {
+      return void 0;
+    } else if (isCacheControl(cacheOption)) {
+      return cacheOption;
+    } else if (isCacheOptionProvider(cacheOption)) {
+      return cacheOption(req);
+    } else {
+      var url = req.url;
+      var options = Object.entries(cacheOption);
+      var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+      try {
+        for (var _iterator = options[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], option = _step_value[1];
+          if (key === "*" || new RegExp(key).test(url)) {
+            if (typeof option === "function") {
+              return option(req);
+            } else {
+              return option;
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      return void 0;
+    }
+    function isCacheOptionProvider(option2) {
+      return typeof option2 === "function";
+    }
+    function isCacheControl(option2) {
+      return typeof option2 === "object" && option2 !== null && "maxAge" in option2;
+    }
+  };
+  _proto.getCache = function getCache(req, cacheControl, render, ssrContext) {
+    var _this = this;
+    return _async_to_generator(function() {
+      var renderResult;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            if (!_this.cacheManger)
+              return [
+                3,
+                1
+              ];
+            return [
+              2,
+              _this.cacheManger.getCacheResult(req, cacheControl, render, ssrContext)
+            ];
+          case 1:
+            return [
+              4,
+              render(ssrContext)
+            ];
+          case 2:
+            renderResult = _state.sent();
+            return [
+              2,
+              {
+                data: renderResult
+              }
+            ];
+          case 3:
+            return [
+              2
+            ];
+        }
+      });
+    })();
+  };
+  return ServerCache2;
+}();
+var ssrCache = new ServerCache();
+export {
+  CacheManager,
+  ssrCache
+};

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

@@ -0,0 +1,269 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { SERVER_RENDER_FUNCTION_NAME, MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import * as isbot from "isbot";
+import { getRuntimeEnv, parseHeaders, parseQuery, getHost, getPathname } from "../../utils";
+import { X_RENDER_CACHE } from "../../constants";
+import { ServerTiming } from "./serverTiming";
+var defaultReporter = {
+  init: function init() {
+  },
+  reportError: function reportError() {
+  },
+  reportTiming: function reportTiming() {
+  },
+  reportInfo: function reportInfo() {
+  },
+  reportWarn: function reportWarn() {
+  }
+};
+function ssrRender(request, _) {
+  return _ssrRender.apply(this, arguments);
+}
+function _ssrRender() {
+  _ssrRender = _async_to_generator(function(request, param) {
+    var routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, metrics, _serverManifest_renderBundles, entryName, loadableStats, routeManifest, host, isSpider, responseProxy, query, headers, key, ssrContext, renderBundle, runtimeEnv, ssrResult, cacheStatus, render, cacheModuleName, ssrCache, incomingMessage, cacheControl, _ref, data, status, redirection, headers1, Readable, streamModule, createReadableStreamFromReadable, _tmp, data1;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          routeInfo = param.routeInfo, html = param.html, staticGenerate = param.staticGenerate, nonce = param.nonce, metaName = param.metaName, reporter = param.reporter, logger = param.logger, nodeReq = param.nodeReq, serverManifest = param.serverManifest, locals = param.locals, metrics = param.metrics;
+          entryName = routeInfo.entryName;
+          loadableStats = serverManifest.loadableStats || {};
+          routeManifest = serverManifest.routeManifest || {};
+          host = getHost(request);
+          isSpider = isbot.default(request.headers.get("user-agent"));
+          responseProxy = new ResponseProxy();
+          query = parseQuery(request);
+          headers = parseHeaders(request);
+          if (nodeReq) {
+            for (var key2 in nodeReq.headers) {
+              if (!headers[key2]) {
+                headers[key2] = nodeReq.headers[key2];
+              }
+            }
+          }
+          ssrContext = {
+            request: {
+              baseUrl: routeInfo.urlPath,
+              params: {},
+              pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : getPathname(request),
+              host,
+              query,
+              url: nodeReq ? getHrefFromNodeReq(nodeReq) : request.url,
+              headers
+            },
+            response: {
+              setHeader: function setHeader(key3, value) {
+                responseProxy.headers.set(key3, value);
+              },
+              status: function status2(code) {
+                responseProxy.status = code;
+              },
+              locals: locals || {}
+            },
+            redirection: {},
+            template: html,
+            loadableStats,
+            routeManifest,
+            entryName,
+            staticGenerate,
+            logger,
+            metrics,
+            serverTiming: new ServerTiming(responseProxy.headers, metaName),
+            reporter: reporter || defaultReporter,
+            /** @deprecated node req */
+            req: nodeReq || request,
+            /** @deprecated node res  */
+            res: void 0,
+            isSpider,
+            nonce
+          };
+          renderBundle = (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[entryName || MAIN_ENTRY_NAME];
+          if (!renderBundle) {
+            throw new Error("Can't found renderBundle ".concat(entryName || MAIN_ENTRY_NAME));
+          }
+          runtimeEnv = getRuntimeEnv();
+          render = renderBundle[SERVER_RENDER_FUNCTION_NAME];
+          if (!(runtimeEnv === "node"))
+            return [
+              3,
+              7
+            ];
+          cacheModuleName = "./ssrCache";
+          return [
+            4,
+            import(cacheModuleName)
+          ];
+        case 1:
+          ssrCache = _state.sent().ssrCache;
+          incomingMessage = nodeReq ? nodeReq : new IncomingMessgeProxy(request);
+          return [
+            4,
+            ssrCache.matchCacheControl(incomingMessage)
+          ];
+        case 2:
+          cacheControl = _state.sent();
+          if (!cacheControl)
+            return [
+              3,
+              4
+            ];
+          return [
+            4,
+            ssrCache.getCache(request, cacheControl, render, ssrContext)
+          ];
+        case 3:
+          _ref = _state.sent(), data = _ref.data, status = _ref.status;
+          ssrResult = data;
+          cacheStatus = status;
+          return [
+            3,
+            6
+          ];
+        case 4:
+          return [
+            4,
+            render(ssrContext)
+          ];
+        case 5:
+          ssrResult = _state.sent();
+          _state.label = 6;
+        case 6:
+          return [
+            3,
+            9
+          ];
+        case 7:
+          return [
+            4,
+            render(ssrContext)
+          ];
+        case 8:
+          ssrResult = _state.sent();
+          _state.label = 9;
+        case 9:
+          redirection = ssrContext.redirection;
+          if (cacheStatus) {
+            responseProxy.headers.set(X_RENDER_CACHE, cacheStatus);
+          }
+          if (redirection.url) {
+            headers1 = responseProxy.headers;
+            headers1.set("Location", redirection.url);
+            return [
+              2,
+              new Response(null, {
+                status: redirection.status || 302,
+                headers: {
+                  Location: redirection.url
+                }
+              })
+            ];
+          }
+          return [
+            4,
+            import("stream").catch(function(_) {
+              return {
+                Readable: void 0
+              };
+            })
+          ];
+        case 10:
+          Readable = _state.sent().Readable;
+          streamModule = "../../adapters/node/polyfills/stream";
+          if (!(runtimeEnv === "node"))
+            return [
+              3,
+              12
+            ];
+          return [
+            4,
+            import(streamModule).catch(function(_) {
+              return {
+                createReadableStreamFromReadable: void 0
+              };
+            })
+          ];
+        case 11:
+          _tmp = _state.sent();
+          return [
+            3,
+            13
+          ];
+        case 12:
+          _tmp = {
+            createReadableStreamFromReadable: void 0
+          };
+          _state.label = 13;
+        case 13:
+          createReadableStreamFromReadable = _tmp.createReadableStreamFromReadable;
+          data1 = Readable && _instanceof(ssrResult, Readable) ? (createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(ssrResult)) || "" : ssrResult;
+          if (typeof data1 !== "string") {
+            responseProxy.headers.set("transfer-encoding", "chunked");
+          }
+          return [
+            2,
+            new Response(data1, {
+              status: responseProxy.status,
+              headers: responseProxy.headers
+            })
+          ];
+      }
+    });
+  });
+  return _ssrRender.apply(this, arguments);
+}
+var ResponseProxy = function ResponseProxy2() {
+  "use strict";
+  _class_call_check(this, ResponseProxy2);
+  this.headers = new Headers();
+  this.status = 200;
+  this.headers.set("content-type", "text/html; charset=UTF-8");
+};
+var IncomingMessgeProxy = function IncomingMessgeProxy2(req) {
+  "use strict";
+  var _this = this;
+  _class_call_check(this, IncomingMessgeProxy2);
+  this.headers = {};
+  req.headers.forEach(function(value, key) {
+    _this.headers[key] = value;
+  });
+  this.method = req.method;
+  this.url = getPathname(req);
+};
+function getHrefFromNodeReq(nodeReq) {
+  function getProtocal() {
+    if (nodeReq.socket.encrypted) {
+      return "https";
+    }
+    var proto = nodeReq.headers["x-forwarded-proto"];
+    return proto ? proto.split(/\s*,\s*/, 1)[0] : "http";
+  }
+  function getHost2() {
+    var host = nodeReq.headers["x-forwarded-host"];
+    if (!host) {
+      host = nodeReq.headers.host;
+    }
+    host = host.split(/\s*,\s*/, 1)[0] || "undefined";
+    return host;
+  }
+  var href = "".concat(getProtocal(), "://").concat(getHost2()).concat(nodeReq.url || "");
+  return href;
+}
+function getPathnameFromNodeReq(nodeReq) {
+  var url = nodeReq.url;
+  if (!url) {
+    return "/";
+  }
+  var match = url.match(/\/[^?]*/);
+  var pathname = match ? match[0] : "/";
+  if (pathname !== "/" && pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  return pathname;
+}
+export {
+  getPathnameFromNodeReq,
+  ssrRender
+};