@modern-js/prod-server 2.42.2 → 2.44.0

package/dist/esm/libs/render/ssrCache/cacheMod.js

@@ -0,0 +1,33 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import path from "path";
+import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
+var CACHE_FILENAME = "cache";
+var ServerCacheMod = /* @__PURE__ */ function() {
+  "use strict";
+  function ServerCacheMod2() {
+    _class_call_check(this, ServerCacheMod2);
+    _define_property(this, "customContainer", void 0);
+    _define_property(this, "cacheOption", void 0);
+  }
+  _create_class(ServerCacheMod2, [
+    {
+      key: "loadServerCacheMod",
+      value: function loadServerCacheMod() {
+        var pwd = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : process.cwd();
+        var serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
+        var mod = requireExistModule(serverCacheFilepath, {
+          interop: false
+        });
+        this.customContainer = mod === null || mod === void 0 ? void 0 : mod.customContainer;
+        this.cacheOption = mod === null || mod === void 0 ? void 0 : mod.cacheOption;
+      }
+    }
+  ]);
+  return ServerCacheMod2;
+}();
+var cacheMod = new ServerCacheMod();
+export {
+  cacheMod
+};

package/dist/esm/libs/render/ssrCache/index.js

@@ -0,0 +1,146 @@
+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 { Transform } from "stream";
+import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
+import { cacheMod } from "./cacheMod";
+import { CacheManager } from "./manager";
+var cacheStorage = createMemoryStorage("__ssr__cache");
+function ssrCache(req, render, ssrContext) {
+  return _ssrCache.apply(this, arguments);
+}
+function _ssrCache() {
+  _ssrCache = _async_to_generator(function(req, render, ssrContext) {
+    var customContainer, cacheOption, cacheControl, cacheManager, renderResult, stream;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          customContainer = cacheMod.customContainer, cacheOption = cacheMod.cacheOption;
+          return [
+            4,
+            matchCacheControl(req, cacheOption)
+          ];
+        case 1:
+          cacheControl = _state.sent();
+          cacheManager = new CacheManager(customContainer ? customContainer : cacheStorage);
+          if (!cacheControl)
+            return [
+              3,
+              2
+            ];
+          return [
+            2,
+            cacheManager.getCacheResult(req, cacheControl, render, ssrContext)
+          ];
+        case 2:
+          return [
+            4,
+            render(ssrContext)
+          ];
+        case 3:
+          renderResult = _state.sent();
+          if (typeof renderResult === "string") {
+            return [
+              2,
+              renderResult
+            ];
+          } else {
+            stream = new Transform({
+              write: function write(chunk, _, callback) {
+                this.push(chunk);
+                callback();
+              }
+            });
+            return [
+              2,
+              renderResult(stream)
+            ];
+          }
+          _state.label = 4;
+        case 4:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _ssrCache.apply(this, arguments);
+}
+function matchCacheControl(req, cacheOption) {
+  return _matchCacheControl.apply(this, arguments);
+}
+function _matchCacheControl() {
+  _matchCacheControl = _async_to_generator(function(req, cacheOption) {
+    var url, options, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, option;
+    function isCacheOptionProvider(option2) {
+      return typeof option2 === "function";
+    }
+    function isCacheControl(option2) {
+      return typeof option2 === "object" && option2 !== null && "maxAge" in option2;
+    }
+    return _ts_generator(this, function(_state) {
+      if (!cacheOption) {
+        return [
+          2,
+          void 0
+        ];
+      } else if (isCacheControl(cacheOption)) {
+        return [
+          2,
+          cacheOption
+        ];
+      } else if (isCacheOptionProvider(cacheOption)) {
+        return [
+          2,
+          cacheOption(req)
+        ];
+      } else {
+        url = req.url;
+        options = Object.entries(cacheOption);
+        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+          for (_iterator = options[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            _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 [
+                  2,
+                  option(req)
+                ];
+              } else {
+                return [
+                  2,
+                  option
+                ];
+              }
+            }
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+        return [
+          2,
+          void 0
+        ];
+      }
+      return [
+        2
+      ];
+    });
+  });
+  return _matchCacheControl.apply(this, arguments);
+}
+export {
+  ssrCache
+};

package/dist/esm/libs/render/ssrCache/manager.js

@@ -0,0 +1,159 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { Transform } from "stream";
+var CacheManager = /* @__PURE__ */ function() {
+  "use strict";
+  function CacheManager2(container) {
+    _class_call_check(this, CacheManager2);
+    _define_property(this, "container", void 0);
+    this.container = container;
+  }
+  _create_class(CacheManager2, [
+    {
+      key: "getCacheResult",
+      value: 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,
+                      cache.val
+                    ];
+                  } else if (interval <= staleWhileRevalidate + maxAge) {
+                    _this.processCache(key, render, ssrContext, ttl);
+                    return [
+                      2,
+                      cache.val
+                    ];
+                  } else {
+                    return [
+                      2,
+                      _this.processCache(key, render, ssrContext, ttl)
+                    ];
+                  }
+                } else {
+                  return [
+                    2,
+                    _this.processCache(key, render, ssrContext, ttl)
+                  ];
+                }
+                return [
+                  2
+                ];
+            }
+          });
+        })();
+      }
+    },
+    {
+      key: "processCache",
+      value: function processCache(key, render, ssrContext, ttl) {
+        var _this = this;
+        return _async_to_generator(function() {
+          var renderResult, current, cache, html, stream;
+          return _ts_generator(this, function(_state) {
+            switch (_state.label) {
+              case 0:
+                return [
+                  4,
+                  render(ssrContext)
+                ];
+              case 1:
+                renderResult = _state.sent();
+                if (!(typeof renderResult === "string"))
+                  return [
+                    3,
+                    3
+                  ];
+                current = Date.now();
+                cache = {
+                  val: renderResult,
+                  cursor: current
+                };
+                return [
+                  4,
+                  _this.container.set(key, JSON.stringify(cache), {
+                    ttl
+                  })
+                ];
+              case 2:
+                _state.sent();
+                return [
+                  2,
+                  renderResult
+                ];
+              case 3:
+                stream = new Transform({
+                  write: function write(chunk, _, callback) {
+                    html += chunk.toString();
+                    this.push(chunk);
+                    callback();
+                  }
+                });
+                stream.on("close", function() {
+                  var current2 = Date.now();
+                  var cache2 = {
+                    val: html,
+                    cursor: current2
+                  };
+                  _this.container.set(key, JSON.stringify(cache2), {
+                    ttl
+                  });
+                });
+                return [
+                  2,
+                  renderResult(stream)
+                ];
+              case 4:
+                return [
+                  2
+                ];
+            }
+          });
+        })();
+      }
+    },
+    {
+      key: "computedKey",
+      value: function computedKey(req, cacheControl) {
+        var url = req.url;
+        var _url_split = _sliced_to_array(url.split("?"), 1), pathname = _url_split[0];
+        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;
+}();
+export {
+  CacheManager
+};

package/dist/esm/libs/render/static.js

@@ -2,7 +2,7 @@ import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { mime } from "@modern-js/utils";
-import { readFile } from "./reader";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
 function handleDirectory(ctx, entryPath, urlPath) {
   return _handleDirectory.apply(this, arguments);
 }
@@ -16,7 +16,7 @@ function _handleDirectory() {
           filepath = path.join(entryPath, trimLeft(pathname, urlPath));
           return [
             4,
-            readFile(filepath)
+            fileReader.readFile(filepath)
           ];
         case 1:
           content = _state.sent();
@@ -33,7 +33,7 @@ function _handleDirectory() {
             ];
           return [
             4,
-            readFile("".concat(filepath, "index.html"))
+            fileReader.readFile("".concat(filepath, "index.html"))
           ];
         case 2:
           content = _state.sent();
@@ -49,7 +49,7 @@ function _handleDirectory() {
             ];
           return [
             4,
-            readFile("".concat(filepath, ".html"))
+            fileReader.readFile("".concat(filepath, ".html"))
           ];
         case 4:
           content = _state.sent();
@@ -60,7 +60,7 @@ function _handleDirectory() {
             ];
           return [
             4,
-            readFile("".concat(filepath, "/index.html"))
+            fileReader.readFile("".concat(filepath, "/index.html"))
           ];
         case 5:
           content = _state.sent();

package/dist/esm/server/index.js

@@ -217,11 +217,21 @@ var Server = /* @__PURE__ */ function() {
       value: function close() {
         var _this = this;
         return _async_to_generator(function() {
+          var _this_server_close, _this_server;
           return _ts_generator(this, function(_state) {
-            _this.app.close();
-            return [
-              2
-            ];
+            switch (_state.label) {
+              case 0:
+                return [
+                  4,
+                  (_this_server_close = (_this_server = _this.server).close) === null || _this_server_close === void 0 ? void 0 : _this_server_close.call(_this_server)
+                ];
+              case 1:
+                _state.sent();
+                _this.app.close();
+                return [
+                  2
+                ];
+            }
           });
         })();
       }

package/dist/esm/server/modernServer.js

@@ -13,11 +13,11 @@ import { RouteMatchManager } from "../libs/route";
 import { createRenderHandler } from "../libs/render";
 import { createStaticFileHandler, faviconFallbackHandler } from "../libs/serveFile";
 import { createErrorDocument, createMiddlewareCollecter, getStaticReg, mergeExtension, noop, debug, isRedirect } from "../utils";
-import * as reader from "../libs/render/reader";
 import { createProxyHandler } from "../libs/proxy";
 import { createContext } from "../libs/context";
 import { AGGRED_DIR, ERROR_DIGEST, ERROR_PAGE_TEXT, RUN_MODE, ServerReportTimings } from "../constants";
 import { createAfterMatchContext, createAfterRenderContext, createMiddlewareContext } from "../libs/hook-api";
+import { cacheMod } from "../libs/render/ssrCache/cacheMod";
 var SERVER_DIR = "./server";
 var ModernServer = /* @__PURE__ */ function() {
   "use strict";
@@ -35,7 +35,6 @@ var ModernServer = /* @__PURE__ */ function() {
     _define_property(this, "logger", void 0);
     _define_property(this, "metrics", void 0);
     _define_property(this, "runMode", void 0);
-    _define_property(this, "reader", reader);
     _define_property(this, "proxyTarget", void 0);
     _define_property(this, "routeRenderHandler", void 0);
     _define_property(this, "staticGenerate", void 0);
@@ -73,7 +72,6 @@ var ModernServer = /* @__PURE__ */ function() {
                 case 0:
                   _this.runner = runner;
                   distDir = _this.distDir, conf = _this.conf;
-                  _this.initReader();
                   debug("final server conf", _this.conf);
                   if ((_conf_bff = conf.bff) === null || _conf_bff === void 0 ? void 0 : _conf_bff.proxy) {
                     _createProxyHandler = createProxyHandler(conf.bff.proxy), handlers = _createProxyHandler.handlers, handleUpgrade = _createProxyHandler.handleUpgrade;
@@ -82,12 +80,10 @@ var ModernServer = /* @__PURE__ */ function() {
                       _this.addHandler(handler);
                     });
                   }
-                  app === null || app === void 0 ? void 0 : app.on("close", function() {
-                    _this.reader.close();
-                  });
                   usageRoutes = _this.filterRoutes(_this.getRoutes());
                   _this.router.reset(usageRoutes);
                   _this.warmupSSRBundle();
+                  cacheMod.loadServerCacheMod(_this.pwd);
                   return [
                     4,
                     _this.prepareFrameHandler()
@@ -218,47 +214,41 @@ var ModernServer = /* @__PURE__ */ function() {
       }
     },
     {
-      key: "initReader",
+      key: "onServerChange",
       value: (
         /* —————————————————————— function will be overwrite —————————————————————— */
-        function initReader() {
-          this.reader.init();
+        function onServerChange(param) {
+          var filepath = param.filepath;
+          var _this = this;
+          return _async_to_generator(function() {
+            var pwd, api, server, apiPath, serverPath, onlyApi, onlyWeb;
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  pwd = _this.pwd;
+                  api = AGGRED_DIR.api, server = AGGRED_DIR.server;
+                  apiPath = path.normalize(path.join(pwd, api));
+                  serverPath = path.normalize(path.join(pwd, server));
+                  onlyApi = filepath.startsWith(apiPath);
+                  onlyWeb = filepath.startsWith(serverPath);
+                  return [
+                    4,
+                    _this.prepareFrameHandler({
+                      onlyWeb,
+                      onlyApi
+                    })
+                  ];
+                case 1:
+                  _state.sent();
+                  return [
+                    2
+                  ];
+              }
+            });
+          })();
         }
       )
     },
-    {
-      key: "onServerChange",
-      value: function onServerChange(param) {
-        var filepath = param.filepath;
-        var _this = this;
-        return _async_to_generator(function() {
-          var pwd, api, server, apiPath, serverPath, onlyApi, onlyWeb;
-          return _ts_generator(this, function(_state) {
-            switch (_state.label) {
-              case 0:
-                pwd = _this.pwd;
-                api = AGGRED_DIR.api, server = AGGRED_DIR.server;
-                apiPath = path.normalize(path.join(pwd, api));
-                serverPath = path.normalize(path.join(pwd, server));
-                onlyApi = filepath.startsWith(apiPath);
-                onlyWeb = filepath.startsWith(serverPath);
-                return [
-                  4,
-                  _this.prepareFrameHandler({
-                    onlyWeb,
-                    onlyApi
-                  })
-                ];
-              case 1:
-                _state.sent();
-                return [
-                  2
-                ];
-            }
-          });
-        })();
-      }
-    },
     {
       key: "getRoutes",
       value: (

package/dist/esm-node/libs/hook-api/afterRenderForStream.js

@@ -0,0 +1,10 @@
+import { Transform } from "stream";
+const afterRenderInjectableStream = (fn) => new Transform({
+  async write(chunk, _, callback) {
+    this.push(await fn(chunk.toString()));
+    callback();
+  }
+});
+export {
+  afterRenderInjectableStream
+};

package/dist/esm-node/libs/hook-api/index.js

@@ -25,6 +25,16 @@ const createAfterRenderContext = (context, route, content) => {
     template: new TemplateAPI(content)
   };
 };
+const createAfterStreamingRenderContext = (context, route) => {
+  const baseContext = base(context);
+  return (chunk) => {
+    return {
+      ...baseContext,
+      route,
+      chunk
+    };
+  };
+};
 const createMiddlewareContext = (context) => {
   const baseContext = base(context);
   baseContext.response.locals = context.res.locals || {};
@@ -42,5 +52,6 @@ export {
   base,
   createAfterMatchContext,
   createAfterRenderContext,
+  createAfterStreamingRenderContext,
   createMiddlewareContext
 };

package/dist/esm-node/libs/render/index.js

@@ -1,9 +1,9 @@
 import path from "path";
 import { cutNameByHyphen, mime } from "@modern-js/utils";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
 import { ERROR_DIGEST } from "../../constants";
 import { shouldFlushServerHeader } from "../preload/shouldFlushServerHeader";
 import { handleDirectory } from "./static";
-import { readFile } from "./reader";
 import * as ssr from "./ssr";
 import { injectServerData } from "./utils";
 const calcFallback = (metaName) => `x-${cutNameByHyphen(metaName)}-ssr-fallback`;
@@ -18,7 +18,7 @@ const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, s
     return result;
   }
   const templatePath = entry;
-  const content = await readFile(templatePath);
+  const content = await fileReader.readFile(templatePath);
   if (!content) {
     return null;
   }
@@ -41,22 +41,12 @@ const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, s
       }
       const ssrRenderOptions = {
         distDir,
-        entryName: route.entryName,
-        urlPath: route.urlPath,
-        bundle: route.bundle,
+        route,
         template: content.toString(),
         staticGenerate,
         nonce
       };
-      const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, {
-        distDir,
-        entryName: route.entryName,
-        urlPath: route.urlPath,
-        bundle: route.bundle,
-        template: content.toString(),
-        staticGenerate,
-        nonce
-      }, runner));
+      const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, ssrRenderOptions, runner));
       return result;
     } catch (err) {
       ctx.error(ERROR_DIGEST.ERENDER, err.stack || err.message);

package/dist/esm-node/libs/render/ssr.js

@@ -1,11 +1,14 @@
 import path from "path";
 import { fs, mime, LOADABLE_STATS_FILE, ROUTE_MANIFEST_FILE, SERVER_RENDER_FUNCTION_NAME } from "@modern-js/utils";
-import cache from "./cache";
+import { createAfterStreamingRenderContext } from "../hook-api";
+import { afterRenderInjectableStream } from "../hook-api/afterRenderForStream";
 import { createLogger, createMetrics } from "./measure";
 import { injectServerDataStream, injectServerData } from "./utils";
+import { ssrCache } from "./ssrCache";
 const render = async (ctx, renderOptions, runner) => {
   var _ctx_res;
-  const { urlPath, bundle, distDir, template, entryName, staticGenerate, enableUnsafeCtx = false, nonce } = renderOptions;
+  const { distDir, route, template, staticGenerate, enableUnsafeCtx = false, nonce } = renderOptions;
+  const { urlPath, bundle, entryName } = route;
   const bundleJS = path.join(distDir, bundle);
   const loadableUri = path.join(distDir, LOADABLE_STATS_FILE);
   const loadableStats = fs.existsSync(loadableUri) ? require(loadableUri) : "";
@@ -50,7 +53,7 @@ const render = async (ctx, renderOptions, runner) => {
   runner.extendSSRContext(context);
   const bundleJSContent = await Promise.resolve(require(bundleJS));
   const serverRender = bundleJSContent[SERVER_RENDER_FUNCTION_NAME];
-  const content = await cache(serverRender, ctx)(context);
+  const content = await ssrCache(ctx.req, serverRender, context);
   const { url, status = 302 } = context.redirection;
   if (url) {
     return {
@@ -66,9 +69,17 @@ const render = async (ctx, renderOptions, runner) => {
       contentType: mime.contentType("html")
     };
   } else {
+    let contentStream = injectServerDataStream(content, ctx);
+    const afterStreamingRenderContext = createAfterStreamingRenderContext(ctx, route);
+    contentStream = contentStream.pipe(afterRenderInjectableStream((chunk) => {
+      const context2 = afterStreamingRenderContext(chunk);
+      return runner.afterStreamingRender(context2, {
+        onLast: ({ chunk: chunk2 }) => chunk2
+      });
+    }));
     return {
       content: "",
-      contentStream: injectServerDataStream(content, ctx),
+      contentStream,
       contentType: mime.contentType("html")
     };
   }

package/dist/esm-node/libs/render/ssrCache/cacheMod.js

@@ -0,0 +1,22 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import path from "path";
+import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
+const CACHE_FILENAME = "cache";
+class ServerCacheMod {
+  loadServerCacheMod(pwd = process.cwd()) {
+    const serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
+    const mod = requireExistModule(serverCacheFilepath, {
+      interop: false
+    });
+    this.customContainer = mod === null || mod === void 0 ? void 0 : mod.customContainer;
+    this.cacheOption = mod === null || mod === void 0 ? void 0 : mod.cacheOption;
+  }
+  constructor() {
+    _define_property(this, "customContainer", void 0);
+    _define_property(this, "cacheOption", void 0);
+  }
+}
+const cacheMod = new ServerCacheMod();
+export {
+  cacheMod
+};