@modern-js/prod-server 2.21.0 → 2.22.0

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

@@ -3,7 +3,7 @@ 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 _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { fs } from "@modern-js/utils";
+import { fs as extraFS } from "@modern-js/utils";
 import LRU from "lru-cache";
 var Byte = 1;
 var KB = 1024 * Byte;
@@ -12,28 +12,18 @@ var getContentLength = function(cache) {
   return cache.content.length;
 };
 var createCacheItem = function() {
-  var _ref = _async_to_generator(function(filepath, mtime) {
-    var content;
+  var _ref = _async_to_generator(function(content, mtime) {
     return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return [
-            4,
-            fs.readFile(filepath)
-          ];
-        case 1:
-          content = _state.sent();
-          return [
-            2,
-            {
-              content: content,
-              mtime: mtime
-            }
-          ];
-      }
+      return [
+        2,
+        {
+          content: content,
+          mtime: mtime
+        }
+      ];
     });
   });
-  return function createCacheItem2(filepath, mtime) {
+  return function createCacheItem2(content, mtime) {
     return _ref.apply(this, arguments);
   };
 }();
@@ -42,16 +32,19 @@ export var LruReader = /* @__PURE__ */ function() {
   function LruReader2() {
     _class_call_check(this, LruReader2);
     _define_property(this, "cache", void 0);
+    _define_property(this, "fs", void 0);
     this.cache = new LRU({
       max: 256 * MB,
       length: getContentLength,
       maxAge: 5 * 60 * 5e3
     });
+    this.fs = extraFS;
   }
   _create_class(LruReader2, [
     {
       key: "init",
-      value: function init2() {
+      value: function init2(fs) {
+        this.fs = fs || extraFS;
       }
     },
     {
@@ -64,10 +57,11 @@ export var LruReader = /* @__PURE__ */ function() {
       value: function read(filepath) {
         var _this = this;
         return _async_to_generator(function() {
-          var content, stat, item;
+          var fs, content, stat, content1, item;
           return _ts_generator(this, function(_state) {
             switch (_state.label) {
               case 0:
+                fs = _this.fs;
                 if (_this.cache.has(filepath)) {
                   content = _this.cache.get(filepath).content;
                   return [
@@ -98,9 +92,15 @@ export var LruReader = /* @__PURE__ */ function() {
                 }
                 return [
                   4,
-                  createCacheItem(filepath, stat.mtime)
+                  fs.promises.readFile(filepath)
                 ];
               case 1:
+                content1 = _state.sent();
+                return [
+                  4,
+                  createCacheItem(content1, stat.mtime)
+                ];
+              case 2:
                 item = _state.sent();
                 _this.cache.set(filepath, item);
                 return [
@@ -115,7 +115,7 @@ export var LruReader = /* @__PURE__ */ function() {
     {
       key: "update",
       value: function update() {
-        var cache = this.cache;
+        var _this = this, cache = _this.cache, fs = _this.fs;
         var files = cache.keys();
         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
         try {
@@ -181,8 +181,8 @@ export var readFile = function() {
 export var updateFile = function() {
   reader.update();
 };
-export var init = function() {
-  reader.init();
+export var init = function(fs) {
+  reader.init(fs);
 };
 export var close = function() {
   reader.close();

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

@@ -1,4 +1,5 @@
-import { TemplateAPI, templateInjectableStream } from "../hook-api/template";
+import { TemplateAPI } from "../hook-api/template";
+import { templateInjectableStream } from "../hook-api/templateForStream";
 export var injectServerData = function(content, context) {
   var template = new TemplateAPI(content);
   template.prependHead('<script type="application/json" id="__MODERN_SERVER_DATA__">'.concat(JSON.stringify(context.serverData), "</script>"));

package/dist/esm/renderHtml.js

@@ -0,0 +1,141 @@
+import { _ as _assert_this_initialized } from "@swc/helpers/_/_assert_this_initialized";
+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 _inherits } from "@swc/helpers/_/_inherits";
+import { _ as _create_super } from "@swc/helpers/_/_create_super";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { OutgoingMessage } from "http";
+import { Readable } from "stream";
+import { Socket } from "net";
+import { Server } from "./server";
+import { isRedirect } from "./utils";
+var IncomingMessageLike = /* @__PURE__ */ function(Readable2) {
+  "use strict";
+  _inherits(IncomingMessageLike2, Readable2);
+  var _super = _create_super(IncomingMessageLike2);
+  function IncomingMessageLike2(param) {
+    var method = param.method, url = param.url, headers = param.headers;
+    _class_call_check(this, IncomingMessageLike2);
+    var _this;
+    _this = _super.call(this);
+    _define_property(_assert_this_initialized(_this), "headers", void 0);
+    _define_property(_assert_this_initialized(_this), "method", void 0);
+    _define_property(_assert_this_initialized(_this), "url", void 0);
+    _define_property(_assert_this_initialized(_this), "socket", void 0);
+    _this.socket = new Socket();
+    _this.headers = headers || {};
+    _this.headers.host = "localhost:8080";
+    _this.method = method || "get";
+    _this.url = url;
+    return _this;
+  }
+  return IncomingMessageLike2;
+}(Readable);
+var ServerResponseLike = /* @__PURE__ */ function(OutgoingMessage2) {
+  "use strict";
+  _inherits(ServerResponseLike2, OutgoingMessage2);
+  var _super = _create_super(ServerResponseLike2);
+  function ServerResponseLike2() {
+    _class_call_check(this, ServerResponseLike2);
+    var _this;
+    _this = _super.call(this);
+    _define_property(_assert_this_initialized(_this), "statusCode", void 0);
+    _define_property(_assert_this_initialized(_this), "data", void 0);
+    _this.statusCode = 200;
+    _this.data = [];
+    return _this;
+  }
+  _create_class(ServerResponseLike2, [
+    {
+      key: "end",
+      value: function end(chunk, _encoding, cb) {
+        this.data.push(chunk.toString());
+        cb && cb();
+        this.emit("finish");
+        return this;
+      }
+    }
+  ]);
+  return ServerResponseLike2;
+}(OutgoingMessage);
+var CustomServer = /* @__PURE__ */ function(Server2) {
+  "use strict";
+  _inherits(CustomServer2, Server2);
+  var _super = _create_super(CustomServer2);
+  function CustomServer2() {
+    _class_call_check(this, CustomServer2);
+    return _super.apply(this, arguments);
+  }
+  _create_class(CustomServer2, [
+    {
+      key: "render",
+      value: function render(req, res, _url) {
+        var _this = this;
+        return _async_to_generator(function() {
+          var handler;
+          return _ts_generator(this, function(_state) {
+            handler = _this.getRequestHandler();
+            handler(req, res);
+            return [
+              2,
+              null
+            ];
+          });
+        })();
+      }
+    }
+  ]);
+  return CustomServer2;
+}(Server);
+function renderHtml(_) {
+  return _renderHtml.apply(this, arguments);
+}
+function _renderHtml() {
+  _renderHtml = _async_to_generator(function(param) {
+    var url, method, headers, body, serverOptions, req, res, customServer;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          url = param.url, method = param.method, headers = param.headers, body = param.body, serverOptions = param.serverOptions;
+          req = new IncomingMessageLike({
+            method: method,
+            url: url,
+            headers: headers
+          });
+          if (body) {
+            req.push(body);
+            req.push(null);
+          }
+          res = new ServerResponseLike();
+          customServer = new CustomServer(serverOptions);
+          return [
+            4,
+            customServer.init({
+              disableHttpServer: true
+            })
+          ];
+        case 1:
+          _state.sent();
+          customServer.render(req, res);
+          return [
+            2,
+            new Promise(function(resolve) {
+              res.addListener("finish", function() {
+                resolve({
+                  headers: res.getHeaders(),
+                  redirected: isRedirect(res.statusCode),
+                  status: res.statusCode,
+                  url: url,
+                  body: res.data.join()
+                });
+              });
+            })
+          ];
+      }
+    });
+  });
+  return _renderHtml.apply(this, arguments);
+}
+module.exports = renderHtml;

package/dist/esm/server/index.js

@@ -49,6 +49,9 @@ export var Server = /* @__PURE__ */ function() {
         * - 执行 server init
         */
         function init() {
+          var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+            disableHttpServer: false
+          }, _ref_disableHttpServer = _ref.disableHttpServer, disableHttpServer = _ref_disableHttpServer === void 0 ? false : _ref_disableHttpServer;
           var _this = this;
           return _async_to_generator(function() {
             var options;
@@ -94,17 +97,24 @@ export var Server = /* @__PURE__ */ function() {
                   ];
                 case 6:
                   _state.sent();
+                  if (!!disableHttpServer)
+                    return [
+                      3,
+                      8
+                    ];
                   return [
                     4,
                     _this.server.createHTTPServer(_this.getRequestHandler())
                   ];
                 case 7:
                   _this.app = _state.sent();
+                  _state.label = 8;
+                case 8:
                   return [
                     4,
                     _this.server.onInit(_this.runner, _this.app)
                   ];
-                case 8:
+                case 9:
                   _state.sent();
                   return [
                     2,

package/dist/esm/server/modernServer.js

@@ -45,7 +45,7 @@ export var ModernServer = /* @__PURE__ */ function() {
     _define_property(this, "staticGenerate", void 0);
     require("ignore-styles");
     this.pwd = pwd;
-    this.distDir = path.join(pwd, config.output.path || "dist");
+    this.distDir = path.resolve(pwd, config.output.path || "dist");
     this.workDir = this.distDir;
     this.conf = config;
     debug("server conf", this.conf);
@@ -71,6 +71,7 @@ export var ModernServer = /* @__PURE__ */ function() {
                 case 0:
                   _this.runner = runner;
                   distDir = _this.distDir, staticGenerate = _this.staticGenerate, conf = _this.conf;
+                  _this.initReader();
                   debug("final server conf", _this.conf);
                   _this.proxyHandler = createProxyHandler((_conf_bff = conf.bff) === null || _conf_bff === void 0 ? void 0 : _conf_bff.proxy);
                   if (_this.proxyHandler) {
@@ -78,8 +79,7 @@ export var ModernServer = /* @__PURE__ */ function() {
                       _this.addHandler(handler);
                     });
                   }
-                  _this.reader.init();
-                  app.on("close", function() {
+                  app === null || app === void 0 ? void 0 : app.on("close", function() {
                     _this.reader.close();
                   });
                   usageRoutes = _this.filterRoutes(_this.getRoutes());
@@ -132,39 +132,6 @@ export var ModernServer = /* @__PURE__ */ function() {
         }
       )
     },
-    {
-      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: onlyWeb,
-                    onlyApi: onlyApi
-                  })
-                ];
-              case 1:
-                _state.sent();
-                return [
-                  2
-                ];
-            }
-          });
-        })();
-      }
-    },
     {
       key: "getRequestHandler",
       value: (
@@ -235,9 +202,50 @@ export var ModernServer = /* @__PURE__ */ function() {
       }
     },
     {
-      key: "getRoutes",
+      key: "initReader",
       value: (
         /* —————————————————————— function will be overwrite —————————————————————— */
+        function initReader() {
+          this.reader.init();
+        }
+      )
+    },
+    {
+      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: onlyWeb,
+                    onlyApi: onlyApi
+                  })
+                ];
+              case 1:
+                _state.sent();
+                return [
+                  2
+                ];
+            }
+          });
+        })();
+      }
+    },
+    {
+      key: "getRoutes",
+      value: (
         // get routes info
         function getRoutes() {
           if (this.presetRoutes) {

package/dist/esm/workerServer.js

@@ -4,6 +4,8 @@ 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 { createAsyncPipeline } from "@modern-js/plugin";
+import { createAfterMatchContext, createAfterRenderContext, createMiddlewareContext } from "./libs/hook-api/index.worker";
 import { Logger } from "./libs/logger";
 import { RouteMatchManager } from "./libs/route";
 import { metrics as defaultMetrics } from "./libs/metrics";
@@ -65,14 +67,32 @@ export var ReturnResponse = /* @__PURE__ */ function() {
   return ReturnResponse2;
 }();
 var RESPONSE_NOTFOUND = new ReturnResponse("404: Page not found", 404);
+var isRedirect = function(code) {
+  return [
+    301,
+    302,
+    307,
+    308
+  ].includes(code);
+};
+var checkIsSent = function(context) {
+  if (context.res.isSent) {
+    return true;
+  }
+  if (context.res.headers.get("Location") && isRedirect(context.res.status)) {
+    return true;
+  }
+  return false;
+};
+var middlewarePipeline = createAsyncPipeline();
 export var createHandler = function(manifest) {
   var routeMgr = new RouteMatchManager();
   var pages = manifest.pages, routes = manifest.routes;
   routeMgr.reset(routes);
   return function() {
     var _ref = _async_to_generator(function(options) {
-      var request, loadableStats, routeManifest, url, pageMatch, page, responseLike, params, serverRenderContext, body, e;
-      function createServerRequest(url2, request2, params2) {
+      var _page_serverHooks, _page_serverHooks_afterMatch, request, loadableStats, routeManifest, url, pageMatch, entryName, page, logger, metrics, hookContext, afterMatchHookContext, _page_serverHooks1, _page_serverHooks2, _page_serverHooks_afterRender, middlewarsHookContext, responseLike, params, baseUrl, serverRenderContext, body, afterRenderHookContext, e;
+      function createServerRequest(url2, baseUrl2, request2, params2) {
         var pathname = url2.pathname, host = url2.host, searchParams = url2.searchParams;
         var rawHeaders = request2.headers;
         var headers = {};
@@ -81,6 +101,8 @@ export var createHandler = function(manifest) {
         });
         var query = Object.fromEntries(searchParams);
         return {
+          url: url2.href,
+          baseUrl: baseUrl2,
           pathname: pathname,
           host: host,
           headers: headers,
@@ -100,7 +122,23 @@ export var createHandler = function(manifest) {
                 RESPONSE_NOTFOUND
               ];
             }
-            page = pages[pageMatch.spec.urlPath];
+            entryName = pageMatch.spec.urlPath;
+            page = pages[entryName];
+            logger = new Logger({
+              level: "warn"
+            });
+            metrics = defaultMetrics;
+            hookContext = createWorkerHookContext(request.url, logger, metrics);
+            afterMatchHookContext = createAfterMatchContext(hookContext, entryName);
+            page === null || page === void 0 ? void 0 : (_page_serverHooks = page.serverHooks) === null || _page_serverHooks === void 0 ? void 0 : (_page_serverHooks_afterMatch = _page_serverHooks.afterMatch) === null || _page_serverHooks_afterMatch === void 0 ? void 0 : _page_serverHooks_afterMatch.call(_page_serverHooks, afterMatchHookContext, function() {
+              return void 0;
+            });
+            if (checkIsSent(hookContext)) {
+              return [
+                2,
+                new ReturnResponse(hookContext.res.body || "Unkown body", hookContext.res.status, hookContext.res.headers)
+              ];
+            }
             if (!page.serverRender)
               return [
                 3,
@@ -114,6 +152,14 @@ export var createHandler = function(manifest) {
               ,
               4
             ]);
+            middlewarsHookContext = createMiddlewareContext(hookContext);
+            applyMiddlewares(middlewarsHookContext, (_page_serverHooks1 = page.serverHooks) === null || _page_serverHooks1 === void 0 ? void 0 : _page_serverHooks1.middleware);
+            if (checkIsSent(hookContext)) {
+              return [
+                2,
+                new ReturnResponse(hookContext.res.body || "Unkown body", hookContext.res.status, hookContext.res.headers)
+              ];
+            }
             responseLike = {
               headers: {},
               statusCode: 200,
@@ -126,18 +172,17 @@ export var createHandler = function(manifest) {
               }
             };
             params = pageMatch.parseURLParams(url.pathname) || {};
+            baseUrl = pageMatch.urlPath;
             serverRenderContext = {
-              request: createServerRequest(url, request, params),
+              request: createServerRequest(url, baseUrl, request, params),
               response: responseLike,
               loadableStats: loadableStats,
               routeManifest: routeManifest,
               redirection: {},
               template: page.template,
               entryName: page.entryName,
-              logger: new Logger({
-                level: "warn"
-              }),
-              metrics: defaultMetrics,
+              logger: logger,
+              metrics: metrics,
               // FIXME: pass correctly req & res
               req: request,
               res: responseLike
@@ -148,9 +193,19 @@ export var createHandler = function(manifest) {
             ];
           case 2:
             body = _state.sent();
+            afterRenderHookContext = createAfterRenderContext(hookContext, body);
+            (_page_serverHooks2 = page.serverHooks) === null || _page_serverHooks2 === void 0 ? void 0 : (_page_serverHooks_afterRender = _page_serverHooks2.afterRender) === null || _page_serverHooks_afterRender === void 0 ? void 0 : _page_serverHooks_afterRender.call(_page_serverHooks2, afterRenderHookContext, function() {
+              return void 0;
+            });
+            if (checkIsSent(hookContext)) {
+              return [
+                2,
+                new ReturnResponse(hookContext.res.body || "Unkown body", hookContext.res.status, hookContext.res.headers)
+              ];
+            }
             return [
               2,
-              new ReturnResponse(body, responseLike.statusCode, responseLike.headers)
+              new ReturnResponse(afterRenderHookContext.template.get(), responseLike.statusCode, responseLike.headers)
             ];
           case 3:
             e = _state.sent();
@@ -161,7 +216,7 @@ export var createHandler = function(manifest) {
               createResponse(page.template)
             ];
           case 4:
-            console.warn("Can't not page(".concat(pageMatch.spec.urlPath, ") serverRender"));
+            console.warn("Can't not page(".concat(entryName, ") serverRender"));
             return [
               2,
               createResponse(page.template)
@@ -181,3 +236,41 @@ function createResponse(template) {
     return RESPONSE_NOTFOUND;
   }
 }
+function createWorkerHookContext(url, logger, metrics) {
+  var _ref = [
+    {
+      headers: new Headers(),
+      body: "",
+      status: 200,
+      isSent: false
+    },
+    new Request(url)
+  ], res = _ref[0], req = _ref[1];
+  return {
+    res: res,
+    req: req,
+    logger: logger,
+    metrics: metrics
+  };
+}
+function applyMiddlewares(ctx, middleware) {
+  if (middleware) {
+    var middlewares = function() {
+      if (Array.isArray(middleware)) {
+        return middleware;
+      } else {
+        return [
+          middleware
+        ];
+      }
+    }();
+    middlewares.forEach(function(middleware2) {
+      middlewarePipeline.use(middleware2);
+    });
+    middlewarePipeline.run(ctx, {
+      onLast: function() {
+        return void 0;
+      }
+    });
+  }
+}

package/dist/esm-node/libs/context/context.js

@@ -95,7 +95,7 @@ export class ModernServerContext {
     if (!host) {
       host = this.getReqHeader("Host");
     }
-    return host.split(/\s*,\s*/, 1)[0] || "";
+    return host.split(/\s*,\s*/, 1)[0] || "undefined";
   }
   get protocol() {
     if (this.req.socket.encrypted) {

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

@@ -0,0 +1,68 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import cookie from "cookie";
+export class BaseResponse {
+  get(key) {
+    return this.res.getHeader(key);
+  }
+  set(key, value) {
+    return this.res.setHeader(key, value);
+  }
+  status(code) {
+    this.res.statusCode = code;
+  }
+  setCookie(key, value, options) {
+    const cookieValue = String(this.res.getHeader("set-cookie") || "");
+    const fmt = Array.isArray(cookieValue) ? cookieValue : [
+      cookieValue
+    ].filter(Boolean);
+    fmt.push(cookie.serialize(key, value, options));
+    this.res.setHeader("set-cookie", fmt.length === 1 ? fmt[0] : fmt);
+  }
+  clearCookie() {
+    this.res.removeHeader("set-cookie");
+  }
+  raw(body, options) {
+    const { status, headers = {} } = options || {};
+    Object.entries(headers).forEach(([key, value]) => {
+      this.res.setHeader(key, value);
+    });
+    if (status) {
+      this.res.statusCode = status;
+    }
+    this.res.end(body);
+  }
+  constructor(res) {
+    _define_property(this, "cookies", void 0);
+    _define_property(this, "res", void 0);
+    this.res = res;
+    this.cookies = {
+      set: this.setCookie.bind(this),
+      clear: this.clearCookie.bind(this)
+    };
+  }
+}
+export class BaseRequest {
+  getCookie(key) {
+    return this._cookie[key];
+  }
+  constructor(request) {
+    _define_property(this, "url", void 0);
+    _define_property(this, "host", void 0);
+    _define_property(this, "pathname", void 0);
+    _define_property(this, "query", void 0);
+    _define_property(this, "headers", void 0);
+    _define_property(this, "cookie", void 0);
+    _define_property(this, "cookies", void 0);
+    _define_property(this, "_cookie", void 0);
+    this.url = request.url;
+    this.host = request.host;
+    this.pathname = request.path;
+    this.query = request.query;
+    this.headers = request.headers;
+    this.cookie = request.headers.cookie || "";
+    this._cookie = cookie.parse(this.cookie);
+    this.cookies = {
+      get: this.getCookie.bind(this)
+    };
+  }
+}