@modern-js/prod-server 2.42.2 → 2.43.0

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(containter) {
+    _class_call_check(this, CacheManager2);
+    _define_property(this, "containter", void 0);
+    this.containter = containter;
+  }
+  _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.containter.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.containter.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.containter.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/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;
   }
@@ -48,15 +48,7 @@ const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, s
         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,8 +1,8 @@
 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 { 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;
@@ -50,7 +50,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 {

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
+};

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

@@ -0,0 +1,57 @@
+import { Transform } from "stream";
+import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
+import { cacheMod } from "./cacheMod";
+import { CacheManager } from "./manager";
+const cacheStorage = createMemoryStorage("__ssr__cache");
+async function ssrCache(req, render, ssrContext) {
+  const { customContainer, cacheOption } = cacheMod;
+  const cacheControl = await matchCacheControl(req, cacheOption);
+  const cacheManager = new CacheManager(customContainer ? customContainer : cacheStorage);
+  if (cacheControl) {
+    return cacheManager.getCacheResult(req, cacheControl, render, ssrContext);
+  } else {
+    const renderResult = await render(ssrContext);
+    if (typeof renderResult === "string") {
+      return renderResult;
+    } else {
+      const stream = new Transform({
+        write(chunk, _, callback) {
+          this.push(chunk);
+          callback();
+        }
+      });
+      return renderResult(stream);
+    }
+  }
+}
+async function matchCacheControl(req, cacheOption) {
+  if (!cacheOption) {
+    return void 0;
+  } else if (isCacheControl(cacheOption)) {
+    return cacheOption;
+  } else if (isCacheOptionProvider(cacheOption)) {
+    return cacheOption(req);
+  } else {
+    const url = req.url;
+    const options = Object.entries(cacheOption);
+    for (const [key, option] of options) {
+      if (key === "*" || new RegExp(key).test(url)) {
+        if (typeof option === "function") {
+          return option(req);
+        } else {
+          return option;
+        }
+      }
+    }
+    return void 0;
+  }
+  function isCacheOptionProvider(option) {
+    return typeof option === "function";
+  }
+  function isCacheControl(option) {
+    return typeof option === "object" && option !== null && "maxAge" in option;
+  }
+}
+export {
+  ssrCache
+};

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

@@ -0,0 +1,80 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { Transform } from "stream";
+class CacheManager {
+  async getCacheResult(req, cacheControl, render, ssrContext) {
+    const key = this.computedKey(req, cacheControl);
+    const value = await this.containter.get(key);
+    const { maxAge, staleWhileRevalidate } = cacheControl;
+    const ttl = maxAge + staleWhileRevalidate;
+    if (value) {
+      const cache = JSON.parse(value);
+      const interval = Date.now() - cache.cursor;
+      if (interval <= maxAge) {
+        return cache.val;
+      } else if (interval <= staleWhileRevalidate + maxAge) {
+        this.processCache(key, render, ssrContext, ttl);
+        return cache.val;
+      } else {
+        return this.processCache(key, render, ssrContext, ttl);
+      }
+    } else {
+      return this.processCache(key, render, ssrContext, ttl);
+    }
+  }
+  async processCache(key, render, ssrContext, ttl) {
+    const renderResult = await render(ssrContext);
+    if (typeof renderResult === "string") {
+      const current = Date.now();
+      const cache = {
+        val: renderResult,
+        cursor: current
+      };
+      await this.containter.set(key, JSON.stringify(cache), {
+        ttl
+      });
+      return renderResult;
+    } else {
+      let html;
+      const stream = new Transform({
+        write(chunk, _, callback) {
+          html += chunk.toString();
+          this.push(chunk);
+          callback();
+        }
+      });
+      stream.on("close", () => {
+        const current = Date.now();
+        const cache = {
+          val: html,
+          cursor: current
+        };
+        this.containter.set(key, JSON.stringify(cache), {
+          ttl
+        });
+      });
+      return renderResult(stream);
+    }
+  }
+  computedKey(req, cacheControl) {
+    const { url } = req;
+    const [pathname] = url.split("?");
+    const { customKey } = cacheControl;
+    const defaultKey = pathname.replace(/.+\/+$/, "");
+    if (customKey) {
+      if (typeof customKey === "string") {
+        return customKey;
+      } else {
+        return customKey(defaultKey);
+      }
+    } else {
+      return defaultKey;
+    }
+  }
+  constructor(containter) {
+    _define_property(this, "containter", void 0);
+    this.containter = containter;
+  }
+}
+export {
+  CacheManager
+};

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

@@ -1,18 +1,18 @@
 import path from "path";
 import { mime } from "@modern-js/utils";
-import { readFile } from "./reader";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
 async function handleDirectory(ctx, entryPath, urlPath) {
   const { path: pathname } = ctx;
   const filepath = path.join(entryPath, trimLeft(pathname, urlPath));
-  let content = await readFile(filepath);
+  let content = await fileReader.readFile(filepath);
   let contentType = mime.contentType(path.extname(filepath) || "");
   if (!content) {
     if (pathname.endsWith("/")) {
-      content = await readFile(`${filepath}index.html`);
+      content = await fileReader.readFile(`${filepath}index.html`);
     } else if (!pathname.includes(".")) {
-      content = await readFile(`${filepath}.html`);
+      content = await fileReader.readFile(`${filepath}.html`);
       if (!content) {
-        content = await readFile(`${filepath}/index.html`);
+        content = await fileReader.readFile(`${filepath}/index.html`);
       }
     }
     if (content) {

package/dist/esm-node/server/index.js

@@ -88,6 +88,8 @@ class Server {
     });
   }
   async close() {
+    var _this_server_close, _this_server;
+    await ((_this_server_close = (_this_server = this.server).close) === null || _this_server_close === void 0 ? void 0 : _this_server_close.call(_this_server));
     this.app.close();
   }
   listen(options, listener) {

package/dist/esm-node/server/modernServer.js

@@ -7,11 +7,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";
 const SERVER_DIR = "./server";
 class ModernServer {
   // server prepare
@@ -19,7 +19,6 @@ class ModernServer {
     var _conf_bff, _this_conf_output;
     this.runner = runner;
     const { distDir, conf } = this;
-    this.initReader();
     debug("final server conf", this.conf);
     if ((_conf_bff = conf.bff) === null || _conf_bff === void 0 ? void 0 : _conf_bff.proxy) {
       const { handlers, handleUpgrade } = createProxyHandler(conf.bff.proxy);
@@ -28,12 +27,10 @@ class ModernServer {
         this.addHandler(handler);
       });
     }
-    app === null || app === void 0 ? void 0 : app.on("close", () => {
-      this.reader.close();
-    });
     const usageRoutes = this.filterRoutes(this.getRoutes());
     this.router.reset(usageRoutes);
     this.warmupSSRBundle();
+    cacheMod.loadServerCacheMod(this.pwd);
     await this.prepareFrameHandler();
     await this.prepareLoaderHandler(usageRoutes, distDir);
     this.routeRenderHandler = this.getRenderHandler();
@@ -89,9 +86,6 @@ class ModernServer {
     return createServer(handler);
   }
   /* —————————————————————— function will be overwrite —————————————————————— */
-  initReader() {
-    this.reader.init();
-  }
   async onServerChange({ filepath }) {
     const { pwd } = this;
     const { api, server } = AGGRED_DIR;
@@ -475,7 +469,6 @@ class ModernServer {
     _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);

package/dist/types/libs/context/index.d.ts

@@ -1,3 +1,5 @@
+/// <reference path="../../type.d.ts" />
+/// <reference types="node/http" />
 import { IncomingMessage, ServerResponse } from 'http';
 import { ModernServerContext, ContextOptions } from './context';
 export declare const createContext: (req: IncomingMessage, res: ServerResponse, options?: ContextOptions) => ModernServerContext;

package/dist/types/libs/preload/flushServerHeader.d.ts

@@ -1,4 +1,6 @@
+/// <reference path="../../type.d.ts" />
 /// <reference types="node" />
+/// <reference types="node/http" />
 import { OutgoingHttpHeaders } from 'http';
 import { ServerOptions } from '@modern-js/server-core';
 import { ModernServerContext } from '@modern-js/types';

package/dist/types/libs/proxy.d.ts

@@ -1,3 +1,5 @@
+/// <reference path="../type.d.ts" />
+/// <reference types="node/http" />
 import http from 'http';
 import { RequestHandler } from 'http-proxy-middleware';
 import { ProxyDetail, BffProxyOptions } from '@modern-js/types';