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

package/dist/esm/base/adapters/node/middlewares/templates.js

@@ -0,0 +1,114 @@
+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 { fileReader } from "@modern-js/runtime-utils/fileReader";
+function getHtmlTemplates(pwd, routes) {
+  return _getHtmlTemplates.apply(this, arguments);
+}
+function _getHtmlTemplates() {
+  _getHtmlTemplates = _async_to_generator(function(pwd, routes) {
+    var htmls, templates;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            Promise.all(routes.map(function() {
+              var _ref = _async_to_generator(function(route) {
+                var html, _this, htmlPath, e;
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      _state2.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                      ]);
+                      htmlPath = path.join(pwd, route.entryPath);
+                      return [
+                        4,
+                        fileReader.readFile(htmlPath, "utf-8")
+                      ];
+                    case 1:
+                      html = (_this = _state2.sent()) === null || _this === void 0 ? void 0 : _this.toString();
+                      return [
+                        3,
+                        3
+                      ];
+                    case 2:
+                      e = _state2.sent();
+                      return [
+                        3,
+                        3
+                      ];
+                    case 3:
+                      return [
+                        2,
+                        [
+                          route.entryName,
+                          html
+                        ]
+                      ];
+                  }
+                });
+              });
+              return function(route) {
+                return _ref.apply(this, arguments);
+              };
+            }()) || [])
+          ];
+        case 1:
+          htmls = _state.sent();
+          templates = Object.fromEntries(htmls);
+          return [
+            2,
+            templates
+          ];
+      }
+    });
+  });
+  return _getHtmlTemplates.apply(this, arguments);
+}
+function injectTemplates(pwd, routes) {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var templates;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            if (!(routes && !c.get("templates")))
+              return [
+                3,
+                2
+              ];
+            return [
+              4,
+              getHtmlTemplates(pwd, routes)
+            ];
+          case 1:
+            templates = _state.sent();
+            c.set("templates", templates);
+            _state.label = 2;
+          case 2:
+            return [
+              4,
+              next()
+            ];
+          case 3:
+            _state.sent();
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+export {
+  getHtmlTemplates,
+  injectTemplates
+};

package/dist/esm/base/adapters/node/node.js

@@ -0,0 +1,197 @@
+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 { createServer, ServerResponse } from "node:http";
+import { createReadableStreamFromReadable, writeReadableStreamToWritable } from "./polyfills/stream";
+import { installGlobals } from "./polyfills/install";
+installGlobals();
+var createWebRequest = function(req, res) {
+  var _req_url;
+  var headerRecord = [];
+  var len = req.rawHeaders.length;
+  for (var i = 0; i < len; i += 2) {
+    headerRecord.push([
+      req.rawHeaders[i],
+      req.rawHeaders[i + 1]
+    ]);
+  }
+  var method = req.method;
+  var controller = new AbortController();
+  var init = {
+    method,
+    headers: headerRecord,
+    signal: controller.signal
+  };
+  res.on("close", function() {
+    return controller.abort();
+  });
+  if (!(method === "GET" || method === "HEAD") && ((_req_url = req.url) === null || _req_url === void 0 ? void 0 : _req_url.includes("__loader"))) {
+    init.body = createReadableStreamFromReadable(req);
+    init.duplex = "half";
+  }
+  var url = "http://".concat(req.headers.host).concat(req.url);
+  var request = new Request(url, init);
+  return request;
+};
+var sendResponse = function() {
+  var _ref = _async_to_generator(function(response, res) {
+    var _response_headers_get, cookies, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, value;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          res.statusMessage = response.statusText;
+          res.statusCode = response.status;
+          cookies = [];
+          _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+          try {
+            for (_iterator = response.headers.entries()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+              _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+              if (key === "set-cookie") {
+                cookies.push(value);
+              } else {
+                res.setHeader(key, value);
+              }
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+          }
+          if (cookies.length > 0) {
+            res.setHeader("set-cookie", cookies);
+          }
+          if (((_response_headers_get = response.headers.get("Content-Type")) === null || _response_headers_get === void 0 ? void 0 : _response_headers_get.match(/text\/event-stream/i)) && _instanceof(res, ServerResponse)) {
+            res.flushHeaders();
+          }
+          if (!response.body)
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            writeReadableStreamToWritable(response.body, res)
+          ];
+        case 1:
+          _state.sent();
+          return [
+            3,
+            3
+          ];
+        case 2:
+          res.end();
+          _state.label = 3;
+        case 3:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function sendResponse2(response, res) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var handleResponseError = function(e, res) {
+  var err = _instanceof(e, Error) ? e : new Error("unknown error", {
+    cause: e
+  });
+  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+    console.info("The user aborted a request.");
+  } else {
+    console.error(e);
+    if (!res.headersSent) {
+      res.writeHead(500, {
+        "Content-Type": "text/plain"
+      });
+    }
+    res.end("Error: ".concat(err.message));
+    res.destroy(err);
+  }
+};
+var getRequestListener = function(handler) {
+  return function() {
+    var _ref = _async_to_generator(function(req, res) {
+      var request, response, error;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            _state.trys.push([
+              0,
+              4,
+              ,
+              5
+            ]);
+            request = createWebRequest(req, res);
+            return [
+              4,
+              handler(request, {
+                node: {
+                  req,
+                  res
+                }
+              })
+            ];
+          case 1:
+            response = _state.sent();
+            if (!(!res.headersSent && !response.res))
+              return [
+                3,
+                3
+              ];
+            return [
+              4,
+              sendResponse(response, res)
+            ];
+          case 2:
+            _state.sent();
+            _state.label = 3;
+          case 3:
+            return [
+              3,
+              5
+            ];
+          case 4:
+            error = _state.sent();
+            return [
+              2,
+              handleResponseError(error, res)
+            ];
+          case 5:
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(req, res) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+var createNodeServer = function(requestHandler) {
+  var requestListener = getRequestListener(requestHandler);
+  var nodeServer = createServer(requestListener);
+  nodeServer.getRequestListener = function() {
+    return requestListener;
+  };
+  nodeServer.getRequestHandler = function() {
+    return requestHandler;
+  };
+  return nodeServer;
+};
+export {
+  createNodeServer,
+  createWebRequest,
+  sendResponse
+};

package/dist/esm/base/adapters/node/polyfills/index.js

@@ -0,0 +1,2 @@
+export * from "./install";
+export * from "./stream";

package/dist/esm/base/adapters/node/polyfills/install.js

@@ -0,0 +1,48 @@
+import { Request as NodeRequest, Response as NodeResponse, Headers as NodeHeaders, FormData as NodeFormData } from "@web-std/fetch";
+import { TransformStream as NodeTransformStream, ReadableStream as NodeReadableStream, WritableStream as NodeWritableStream } from "@web-std/stream";
+import { File as NodeFile, Blob as NodeBlob } from "@web-std/file";
+if (!Object.getOwnPropertyDescriptor(NodeHeaders.prototype, "getSetCookie")) {
+  Object.defineProperty(NodeHeaders.prototype, "getSetCookie", {
+    value: function getSetCookie() {
+      var cookies = [];
+      this.forEach(function(value, name) {
+        if (name.toLowerCase() === "set-cookie") {
+          cookies.push(value);
+        }
+      });
+      return cookies;
+    }
+  });
+}
+var installGlobals = function() {
+  if (!global.Headers) {
+    global.Headers = NodeHeaders;
+  }
+  if (!global.Request) {
+    global.Request = NodeRequest;
+  }
+  if (!global.Response) {
+    global.Response = NodeResponse;
+  }
+  if (!global.FormData) {
+    global.FormData = NodeFormData;
+  }
+  if (!global.TransformStream) {
+    global.TransformStream = NodeTransformStream;
+  }
+  if (!global.ReadableStream) {
+    global.ReadableStream = NodeReadableStream;
+  }
+  if (!global.WritableStream) {
+    global.WritableStream = NodeWritableStream;
+  }
+  if (!global.File) {
+    global.File = NodeFile;
+  }
+  if (!global.Blob) {
+    global.Blob = NodeBlob;
+  }
+};
+export {
+  installGlobals
+};

package/dist/esm/base/adapters/node/polyfills/stream.js

@@ -0,0 +1,316 @@
+import { _ as _async_iterator } from "@swc/helpers/_/_async_iterator";
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { Stream } from "node:stream";
+function writeReadableStreamToWritable(stream, writable) {
+  return _writeReadableStreamToWritable.apply(this, arguments);
+}
+function _writeReadableStreamToWritable() {
+  _writeReadableStreamToWritable = _async_to_generator(function(stream, writable) {
+    var reader, flushable, _ref, done, value, error;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          reader = stream.getReader();
+          flushable = writable;
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            5,
+            ,
+            6
+          ]);
+          _state.label = 2;
+        case 2:
+          if (false)
+            return [
+              3,
+              4
+            ];
+          return [
+            4,
+            reader.read()
+          ];
+        case 3:
+          _ref = _state.sent(), done = _ref.done, value = _ref.value;
+          if (done) {
+            writable.end();
+            return [
+              3,
+              4
+            ];
+          }
+          writable.write(value);
+          if (typeof flushable.flush === "function") {
+            flushable.flush();
+          }
+          return [
+            3,
+            2
+          ];
+        case 4:
+          return [
+            3,
+            6
+          ];
+        case 5:
+          error = _state.sent();
+          writable.destroy(error);
+          throw error;
+        case 6:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _writeReadableStreamToWritable.apply(this, arguments);
+}
+function writeAsyncIterableToWritable(iterable, writable) {
+  return _writeAsyncIterableToWritable.apply(this, arguments);
+}
+function _writeAsyncIterableToWritable() {
+  _writeAsyncIterableToWritable = _async_to_generator(function(iterable, writable) {
+    var _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, err, error;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          _state.trys.push([
+            0,
+            13,
+            ,
+            14
+          ]);
+          _iteratorAbruptCompletion = false, _didIteratorError = false;
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            6,
+            7,
+            12
+          ]);
+          _iterator = _async_iterator(iterable);
+          _state.label = 2;
+        case 2:
+          return [
+            4,
+            _iterator.next()
+          ];
+        case 3:
+          if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done))
+            return [
+              3,
+              5
+            ];
+          _value = _step.value;
+          chunk = _value;
+          writable.write(chunk);
+          _state.label = 4;
+        case 4:
+          _iteratorAbruptCompletion = false;
+          return [
+            3,
+            2
+          ];
+        case 5:
+          return [
+            3,
+            12
+          ];
+        case 6:
+          err = _state.sent();
+          _didIteratorError = true;
+          _iteratorError = err;
+          return [
+            3,
+            12
+          ];
+        case 7:
+          _state.trys.push([
+            7,
+            ,
+            10,
+            11
+          ]);
+          if (!(_iteratorAbruptCompletion && _iterator.return != null))
+            return [
+              3,
+              9
+            ];
+          return [
+            4,
+            _iterator.return()
+          ];
+        case 8:
+          _state.sent();
+          _state.label = 9;
+        case 9:
+          return [
+            3,
+            11
+          ];
+        case 10:
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+          return [
+            7
+          ];
+        case 11:
+          return [
+            7
+          ];
+        case 12:
+          writable.end();
+          return [
+            3,
+            14
+          ];
+        case 13:
+          error = _state.sent();
+          writable.destroy(error);
+          throw error;
+        case 14:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _writeAsyncIterableToWritable.apply(this, arguments);
+}
+function readableStreamToString(stream, encoding) {
+  return _readableStreamToString.apply(this, arguments);
+}
+function _readableStreamToString() {
+  _readableStreamToString = _async_to_generator(function(stream, encoding) {
+    var reader, chunks, _ref, done, value;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          reader = stream.getReader();
+          chunks = [];
+          _state.label = 1;
+        case 1:
+          if (false)
+            return [
+              3,
+              3
+            ];
+          return [
+            4,
+            reader.read()
+          ];
+        case 2:
+          _ref = _state.sent(), done = _ref.done, value = _ref.value;
+          if (done) {
+            return [
+              3,
+              3
+            ];
+          }
+          if (value) {
+            chunks.push(value);
+          }
+          return [
+            3,
+            1
+          ];
+        case 3:
+          return [
+            2,
+            Buffer.concat(chunks).toString(encoding)
+          ];
+      }
+    });
+  });
+  return _readableStreamToString.apply(this, arguments);
+}
+var createReadableStreamFromReadable = function(source) {
+  var pump = new StreamPump(source);
+  var stream = new ReadableStream(pump, pump);
+  return stream;
+};
+var StreamPump = /* @__PURE__ */ function() {
+  "use strict";
+  function StreamPump2(stream) {
+    _class_call_check(this, StreamPump2);
+    this.highWaterMark = stream.readableHighWaterMark || new Stream.Readable().readableHighWaterMark;
+    this.accumalatedSize = 0;
+    this.stream = stream;
+    this.enqueue = this.enqueue.bind(this);
+    this.error = this.error.bind(this);
+    this.close = this.close.bind(this);
+  }
+  var _proto = StreamPump2.prototype;
+  _proto.size = function size(chunk) {
+    return (chunk === null || chunk === void 0 ? void 0 : chunk.byteLength) || 0;
+  };
+  _proto.start = function start(controller) {
+    this.controller = controller;
+    this.stream.on("data", this.enqueue);
+    this.stream.once("error", this.error);
+    this.stream.once("end", this.close);
+    this.stream.once("close", this.close);
+  };
+  _proto.pull = function pull() {
+    this.resume();
+  };
+  _proto.cancel = function cancel(reason) {
+    if (this.stream.destroy) {
+      this.stream.destroy(reason);
+    }
+    this.stream.off("data", this.enqueue);
+    this.stream.off("error", this.error);
+    this.stream.off("end", this.close);
+    this.stream.off("close", this.close);
+  };
+  _proto.enqueue = function enqueue(chunk) {
+    if (this.controller) {
+      try {
+        var bytes = _instanceof(chunk, Uint8Array) ? chunk : Buffer.from(chunk);
+        var available = (this.controller.desiredSize || 0) - bytes.byteLength;
+        this.controller.enqueue(bytes);
+        if (available <= 0) {
+          this.pause();
+        }
+      } catch (error) {
+        this.controller.error(new Error("Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"));
+        this.cancel();
+      }
+    }
+  };
+  _proto.pause = function pause() {
+    if (this.stream.pause) {
+      this.stream.pause();
+    }
+  };
+  _proto.resume = function resume() {
+    if (this.stream.readable && this.stream.resume) {
+      this.stream.resume();
+    }
+  };
+  _proto.close = function close() {
+    if (this.controller) {
+      this.controller.close();
+      delete this.controller;
+    }
+  };
+  _proto.error = function error(error) {
+    if (this.controller) {
+      this.controller.error(error);
+      delete this.controller;
+    }
+  };
+  return StreamPump2;
+}();
+export {
+  createReadableStreamFromReadable,
+  readableStreamToString,
+  writeAsyncIterableToWritable,
+  writeReadableStreamToWritable
+};

package/dist/esm/base/constants.js

@@ -0,0 +1,31 @@
+var AGGRED_DIR = {
+  mock: "config/mock",
+  server: "server",
+  api: "api",
+  shared: "shared",
+  lambda: "lambda"
+};
+var REPLACE_REG = {
+  before: {
+    head: "<head[^>]*>",
+    body: "<body[^>]*>"
+  },
+  after: {
+    head: "</head>",
+    body: "</body>"
+  }
+};
+var ServerReportTimings;
+(function(ServerReportTimings2) {
+  ServerReportTimings2["SERVER_HANDLE_REQUEST"] = "server-handle-request";
+  ServerReportTimings2["SERVER_MIDDLEWARE"] = "server-middleware";
+  ServerReportTimings2["SERVER_HOOK_AFTER_RENDER"] = "server-hook-after-render";
+  ServerReportTimings2["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
+})(ServerReportTimings || (ServerReportTimings = {}));
+var X_RENDER_CACHE = "x-render-cache";
+export {
+  AGGRED_DIR,
+  REPLACE_REG,
+  ServerReportTimings,
+  X_RENDER_CACHE
+};