@modern-js/server-core 2.53.0 → 2.54.1

package/dist/esm/plugins/render/ssrCache.js

@@ -0,0 +1,266 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+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 { createMemoryStorage } from "@modern-js/runtime-utils/storer";
+import { createTransformStream, getPathname, getRuntimeEnv } from "../../utils";
+function processCache(key, render, ssrContext, ttl, container, status) {
+  return _processCache.apply(this, arguments);
+}
+function _processCache() {
+  _processCache = _async_to_generator(function(key, render, ssrContext, ttl, container, status) {
+    var renderResult, current, cache, Readable, runtimeEnv, streamModule, createReadableStreamFromReadable, _tmp, body, html, stream, reader, writer, push;
+    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,
+            container.set(key, JSON.stringify(cache), {
+              ttl
+            })
+          ];
+        case 3:
+          _state.sent();
+          return [
+            2,
+            {
+              data: renderResult,
+              status
+            }
+          ];
+        case 4:
+          return [
+            4,
+            import("stream").catch(function(_) {
+              return {
+                Readable: void 0
+              };
+            })
+          ];
+        case 5:
+          Readable = _state.sent().Readable;
+          runtimeEnv = getRuntimeEnv();
+          streamModule = "../../adapters/node/polyfills/stream";
+          if (!(runtimeEnv === "node"))
+            return [
+              3,
+              7
+            ];
+          return [
+            4,
+            import(streamModule).catch(function(_) {
+              return {
+                createReadableStreamFromReadable: void 0
+              };
+            })
+          ];
+        case 6:
+          _tmp = _state.sent();
+          return [
+            3,
+            8
+          ];
+        case 7:
+          _tmp = {
+            createReadableStreamFromReadable: void 0
+          };
+          _state.label = 8;
+        case 8:
+          createReadableStreamFromReadable = _tmp.createReadableStreamFromReadable;
+          body = // TODO: remove node:stream, move it to ssr entry.
+          Readable && _instanceof(renderResult, Readable) ? createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(renderResult) : renderResult;
+          html = "";
+          stream = createTransformStream(function(chunk) {
+            html += chunk;
+            return chunk;
+          });
+          reader = body.getReader();
+          writer = stream.writable.getWriter();
+          push = function() {
+            reader.read().then(function(param) {
+              var done = param.done, value = param.value;
+              if (done) {
+                var current2 = Date.now();
+                var cache2 = {
+                  val: html,
+                  cursor: current2
+                };
+                container.set(key, JSON.stringify(cache2), {
+                  ttl
+                });
+                writer.close();
+                return;
+              }
+              writer.write(value);
+              push();
+            });
+          };
+          push();
+          return [
+            2,
+            {
+              data: stream.readable,
+              status
+            }
+          ];
+        case 9:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _processCache.apply(this, arguments);
+}
+var CACHE_NAMESPACE = "__ssr__cache";
+var storage = createMemoryStorage(CACHE_NAMESPACE);
+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;
+  }
+}
+function matchCacheControl(cacheOption, req) {
+  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;
+  }
+}
+function getCacheResult(request, options) {
+  return _getCacheResult.apply(this, arguments);
+}
+function _getCacheResult() {
+  _getCacheResult = _async_to_generator(function(request, options) {
+    var cacheControl, render, ssrContext, _options_container, container, key, value, maxAge, staleWhileRevalidate, ttl, cache, interval;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          cacheControl = options.cacheControl, render = options.render, ssrContext = options.ssrContext, _options_container = options.container, container = _options_container === void 0 ? storage : _options_container;
+          key = computedKey(request, cacheControl);
+          return [
+            4,
+            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) {
+              processCache(key, render, ssrContext, ttl, container);
+              return [
+                2,
+                {
+                  data: cache.val,
+                  status: "stale"
+                }
+              ];
+            } else {
+              return [
+                2,
+                processCache(key, render, ssrContext, ttl, container, "expired")
+              ];
+            }
+          } else {
+            return [
+              2,
+              processCache(key, render, ssrContext, ttl, container, "miss")
+            ];
+          }
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _getCacheResult.apply(this, arguments);
+}
+export {
+  getCacheResult,
+  matchCacheControl
+};

package/dist/esm/{base/middlewares/renderHandler → plugins/render}/ssrRender.js

@@ -5,8 +5,9 @@ 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 { X_MODERNJS_RENDER, X_RENDER_CACHE } from "../../constants";
 import { ServerTiming } from "./serverTiming";
+import { matchCacheControl, getCacheResult } from "./ssrCache";
 var defaultReporter = {
   init: function init() {
   },
@@ -24,11 +25,11 @@ function ssrRender(request, _) {
 }
 function _ssrRender() {
   _ssrRender = _async_to_generator(function(request, param) {
-    var routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, _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;
+    var routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, cacheConfig, _serverManifest_renderBundles, entryName, loadableStats, routeManifest, host, isSpider, responseProxy, query, headers, key, ssrContext, renderBundle, runtimeEnv, ssrResult, cacheStatus, render, 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, params = param.params, metrics = param.metrics, loaderContext = param.loaderContext;
+          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, params = param.params, metrics = param.metrics, loaderContext = param.loaderContext, cacheConfig = param.cacheConfig;
           entryName = routeInfo.entryName;
           loadableStats = serverManifest.loadableStats || {};
           routeManifest = serverManifest.routeManifest || {};
@@ -87,68 +88,48 @@ function _ssrRender() {
           }
           runtimeEnv = getRuntimeEnv();
           render = renderBundle[SERVER_RENDER_FUNCTION_NAME];
-          if (!(runtimeEnv === "node"))
-            return [
-              3,
-              7
-            ];
-          cacheModuleName = "./ssrCache";
           return [
             4,
-            import(cacheModuleName)
+            matchCacheControl(cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.strategy, nodeReq || new IncomingMessgeProxy(request))
           ];
         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
+              3
             ];
           return [
             4,
-            ssrCache.getCache(request, cacheControl, render, ssrContext)
+            getCacheResult(request, {
+              cacheControl,
+              container: cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.container,
+              render,
+              ssrContext
+            })
           ];
-        case 3:
+        case 2:
           _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
+            5
           ];
-        case 7:
+        case 3:
           return [
             4,
             render(ssrContext)
           ];
-        case 8:
+        case 4:
           ssrResult = _state.sent();
-          _state.label = 9;
-        case 9:
+          _state.label = 5;
+        case 5:
           redirection = ssrContext.redirection;
           if (cacheStatus) {
             responseProxy.headers.set(X_RENDER_CACHE, cacheStatus);
           }
+          responseProxy.headers.set(X_MODERNJS_RENDER, "server");
           if (redirection.url) {
             headers1 = responseProxy.headers;
             headers1.set("Location", redirection.url);
@@ -170,13 +151,13 @@ function _ssrRender() {
               };
             })
           ];
-        case 10:
+        case 6:
           Readable = _state.sent().Readable;
           streamModule = "../../adapters/node/polyfills/stream";
           if (!(runtimeEnv === "node"))
             return [
               3,
-              12
+              8
             ];
           return [
             4,
@@ -186,18 +167,18 @@ function _ssrRender() {
               };
             })
           ];
-        case 11:
+        case 7:
           _tmp = _state.sent();
           return [
             3,
-            13
+            9
           ];
-        case 12:
+        case 8:
           _tmp = {
             createReadableStreamFromReadable: void 0
           };
-          _state.label = 13;
-        case 13:
+          _state.label = 9;
+        case 9:
           createReadableStreamFromReadable = _tmp.createReadableStreamFromReadable;
           data1 = Readable && _instanceof(ssrResult, Readable) ? (createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(ssrResult)) || "" : ssrResult;
           if (typeof data1 !== "string") {

package/dist/esm/serverBase.js

@@ -0,0 +1,250 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _class_private_method_get } from "@swc/helpers/_/_class_private_method_get";
+import { _ as _class_private_method_init } from "@swc/helpers/_/_class_private_method_init";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { Hono } from "hono";
+import { createContext } from "@modern-js/plugin";
+import { PluginManager } from "./pluginManager";
+var _getAppContext = /* @__PURE__ */ new WeakSet(), _applyMiddlewares = /* @__PURE__ */ new WeakSet();
+var ServerBase = /* @__PURE__ */ function() {
+  "use strict";
+  function ServerBase2(options) {
+    _class_call_check(this, ServerBase2);
+    _class_private_method_init(this, _getAppContext);
+    _class_private_method_init(this, _applyMiddlewares);
+    this.options = options;
+    var config = options.config, serverConfig = options.serverConfig;
+    var appContext = _class_private_method_get(this, _getAppContext, getAppContext).call(this);
+    this.appContext = appContext;
+    this.pluginManager = new PluginManager({
+      cliConfig: config,
+      appContext,
+      serverConfig
+    });
+    this.app = new Hono();
+  }
+  var _proto = ServerBase2.prototype;
+  _proto.init = function init() {
+    var _this = this;
+    return _async_to_generator(function() {
+      var runner;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              _this.pluginManager.init()
+            ];
+          case 1:
+            runner = _state.sent();
+            _this.runner = runner;
+            return [
+              4,
+              runner.prepare()
+            ];
+          case 2:
+            _state.sent();
+            _class_private_method_get(_this, _applyMiddlewares, applyMiddlewares).call(_this);
+            return [
+              2,
+              _this
+            ];
+        }
+      });
+    })();
+  };
+  _proto.addPlugins = function addPlugins(plugins) {
+    this.pluginManager.addPlugins(plugins);
+  };
+  _create_class(ServerBase2, [
+    {
+      key: "all",
+      get: function get() {
+        return this.app.all.bind(this.app);
+      }
+    },
+    {
+      key: "use",
+      get: function get() {
+        return this.app.use.bind(this.app);
+      }
+    },
+    {
+      key: "get",
+      get: function get() {
+        return this.app.get.bind(this.app);
+      }
+    },
+    {
+      key: "post",
+      get: function get() {
+        return this.app.post.bind(this.app);
+      }
+    },
+    {
+      key: "put",
+      get: function get() {
+        return this.app.put.bind(this.app);
+      }
+    },
+    {
+      key: "delete",
+      get: function get() {
+        return this.app.delete.bind(this.app);
+      }
+    },
+    {
+      key: "patch",
+      get: function get() {
+        return this.app.patch.bind(this.app);
+      }
+    },
+    {
+      key: "handle",
+      get: function get() {
+        return this.app.fetch.bind(this.app);
+      }
+    },
+    {
+      key: "request",
+      get: function get() {
+        return this.app.request.bind(this.app);
+      }
+    },
+    {
+      key: "notFound",
+      get: function get() {
+        return this.app.notFound.bind(this.app);
+      }
+    },
+    {
+      key: "onError",
+      get: function get() {
+        return this.app.onError.bind(this.app);
+      }
+    }
+  ]);
+  return ServerBase2;
+}();
+function getAppContext() {
+  var _this_options = this.options, context = _this_options.appContext, pwd = _this_options.pwd, routes = _this_options.routes, metaName = _this_options.metaName;
+  var appContext = {
+    routes,
+    middlewares: [],
+    appDirectory: (context === null || context === void 0 ? void 0 : context.appDirectory) || "",
+    apiDirectory: context === null || context === void 0 ? void 0 : context.apiDirectory,
+    lambdaDirectory: context === null || context === void 0 ? void 0 : context.lambdaDirectory,
+    sharedDirectory: (context === null || context === void 0 ? void 0 : context.sharedDirectory) || "",
+    distDirectory: pwd,
+    plugins: [],
+    metaName: metaName || "modern-js",
+    serverBase: this
+  };
+  return createContext(appContext);
+}
+function applyMiddlewares() {
+  var middlewares = this.appContext.get().middlewares;
+  var preMiddlewares = [];
+  var defaultMiddlewares = [];
+  var postMiddlewares = [];
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = middlewares[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var middleware = _step.value;
+      switch (middleware.order) {
+        case "pre":
+          preMiddlewares.push(middleware);
+          break;
+        case "post":
+          postMiddlewares.push(middleware);
+          break;
+        default:
+          defaultMiddlewares.push(middleware);
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var finalMiddlewares = [];
+  var insertMiddleware = function(middleware2) {
+    if (middleware2.before) {
+      var targetIndex = finalMiddlewares.findIndex(function(item) {
+        var _middleware_before;
+        if ((_middleware_before = middleware2.before) === null || _middleware_before === void 0 ? void 0 : _middleware_before.includes(item.name)) {
+          return true;
+        } else {
+          return false;
+        }
+      });
+      if (targetIndex !== -1) {
+        finalMiddlewares.splice(targetIndex, 0, middleware2);
+      } else {
+        finalMiddlewares.push(middleware2);
+      }
+    } else {
+      finalMiddlewares.push(middleware2);
+    }
+  };
+  preMiddlewares.forEach(insertMiddleware);
+  defaultMiddlewares.forEach(insertMiddleware);
+  postMiddlewares.forEach(insertMiddleware);
+  var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+  try {
+    for (var _iterator1 = finalMiddlewares[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+      var middleware1 = _step1.value;
+      var _this_app;
+      var _middleware_path = middleware1.path, path = _middleware_path === void 0 ? "*" : _middleware_path, _middleware_method = middleware1.method, method = _middleware_method === void 0 ? "all" : _middleware_method, handler = middleware1.handler;
+      var handlers = handler2Handlers(handler);
+      (_this_app = this.app)[method].apply(_this_app, [
+        path
+      ].concat(_to_consumable_array(handlers)));
+    }
+  } catch (err) {
+    _didIteratorError1 = true;
+    _iteratorError1 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+        _iterator1.return();
+      }
+    } finally {
+      if (_didIteratorError1) {
+        throw _iteratorError1;
+      }
+    }
+  }
+  function handler2Handlers(handler2) {
+    if (Array.isArray(handler2)) {
+      return handler2;
+    } else {
+      return [
+        handler2
+      ];
+    }
+  }
+}
+function createServerBase(options) {
+  if (options == null) {
+    throw new Error("can not start server without options");
+  }
+  var server = new ServerBase(options);
+  return server;
+}
+export {
+  ServerBase,
+  createServerBase
+};

package/dist/esm/types/index.js

@@ -0,0 +1,4 @@
+export * from "./config";
+export * from "./plugin";
+export * from "./render";
+export * from "./server";

package/dist/esm/{base/utils → utils}/index.js

@@ -5,3 +5,4 @@ export * from "./error";
 export * from "./warmup";
 export * from "./entry";
 export * from "./request";
+export * from "./serverConfig";

package/dist/esm/utils/serverConfig.js

@@ -0,0 +1,13 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { merge } from "ts-deepmerge";
+var loadConfig = function(param) {
+  var cliConfig = param.cliConfig, serverConfig = param.serverConfig;
+  var config = merge(_object_spread_props(_object_spread({}, cliConfig), {
+    plugins: []
+  }), serverConfig);
+  return config;
+};
+export {
+  loadConfig
+};