@modern-js/server-core 2.47.0 → 2.47.1-alpha.0

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

@@ -0,0 +1,79 @@
+import path from "node:path";
+import { fs } from "@modern-js/utils";
+import { AGGRED_DIR } from "../../../constants";
+import { connectMid2HonoMid } from "../hono";
+const parseKey = (key) => {
+  const _blank = " ";
+  const splitted = key.split(_blank).filter(Boolean);
+  if (splitted.length > 1) {
+    const [method, pathname] = splitted;
+    return {
+      method: method.toLowerCase(),
+      path: pathname
+    };
+  }
+  return {
+    method: "get",
+    path: key
+  };
+};
+const mockHandlerRegistry = /* @__PURE__ */ new Map();
+const registerMockHandlers = async ({ pwd, server }) => {
+  const exts = [
+    ".ts",
+    ".js"
+  ];
+  let mockFilePath = "";
+  for (const ext of exts) {
+    const maybeMatch = path.join(pwd, `${AGGRED_DIR.mock}/index${ext}`);
+    if (await fs.pathExists(maybeMatch)) {
+      mockFilePath = maybeMatch;
+      break;
+    }
+  }
+  if (!mockFilePath) {
+    return null;
+  }
+  const { default: mockModule, config } = await import(mockFilePath);
+  const enable = config === null || config === void 0 ? void 0 : config.enable;
+  if (enable === false) {
+    return;
+  }
+  if (!mockModule) {
+    throw new Error(`Mock file ${mockFilePath} parsed failed!`);
+  }
+  Object.entries(mockModule).forEach(([key, handler]) => {
+    const { method, path: path2 } = parseKey(key);
+    const methodName = method.toLowerCase();
+    const handlerId = `${methodName}-${path2}`;
+    mockHandlerRegistry.set(handlerId, {
+      handler,
+      isRegistered: false
+    });
+    if (typeof server[methodName] === "function") {
+      const mockHandler = async (c, next) => {
+        var _mockHandlerRegistry_get;
+        if (typeof enable === "function") {
+          const isEnabled = enable(c.env.node.req, c.env.node.res);
+          if (!isEnabled) {
+            return next();
+          }
+        }
+        const handler2 = (_mockHandlerRegistry_get = mockHandlerRegistry.get(handlerId)) === null || _mockHandlerRegistry_get === void 0 ? void 0 : _mockHandlerRegistry_get.handler;
+        if (typeof handler2 === "function") {
+          await connectMid2HonoMid(handler2)(c, next);
+        } else {
+          return c.json(handler2);
+        }
+      };
+      const handlerInfo = mockHandlerRegistry.get(handlerId);
+      if (handlerInfo && !(handlerInfo === null || handlerInfo === void 0 ? void 0 : handlerInfo.isRegistered)) {
+        server[methodName](path2, mockHandler);
+        handlerInfo.isRegistered = true;
+      }
+    }
+  });
+};
+export {
+  registerMockHandlers
+};

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

@@ -0,0 +1,71 @@
+import path from "path";
+import { existsSync, lstatSync } from "fs";
+import { readFile } from "fs/promises";
+import { getMimeType } from "hono/utils/mime";
+import { createErrorHtml } from "../../../utils";
+function createStaticMiddleware(options) {
+  const { pwd } = options;
+  const prefix = options.output.assetPrefix || "/";
+  const { distPath: { css: cssPath, js: jsPath, media: mediaPath } = {} } = options.output;
+  const { favicon, faviconByEntries } = options.html;
+  const favicons = prepareFavicons(favicon, faviconByEntries);
+  const staticFiles = [
+    cssPath,
+    jsPath,
+    mediaPath
+  ].filter((v) => Boolean(v));
+  const staticReg = [
+    "static/",
+    "upload/",
+    ...staticFiles
+  ];
+  const iconReg = [
+    "favicon.ico",
+    "icon.png",
+    ...favicons
+  ];
+  const regPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+  const staticPathRegExp = new RegExp(`^${regPrefix}(${[
+    ...staticReg,
+    ...iconReg
+  ].join("|")})`);
+  return async (c, next) => {
+    const pathname = c.req.path;
+    const hit = staticPathRegExp.test(pathname);
+    if (hit) {
+      const filepath = path.resolve(pwd, pathname.replace(prefix, () => ""));
+      if (!existsSync(filepath)) {
+        return c.html(createErrorHtml(404), 404);
+      }
+      const mimeType = getMimeType(filepath);
+      if (mimeType) {
+        c.header("Content-Type", mimeType);
+      }
+      const stat = lstatSync(filepath);
+      const { size } = stat;
+      const chunk = await readFile(filepath);
+      c.header("Content-Length", String(size));
+      return c.body(chunk, 200);
+    } else {
+      return next();
+    }
+  };
+}
+const prepareFavicons = (favicon, faviconByEntries) => {
+  const faviconNames = [];
+  if (favicon) {
+    faviconNames.push(favicon.substring(favicon.lastIndexOf("/") + 1));
+  }
+  if (faviconByEntries) {
+    Object.keys(faviconByEntries).forEach((f) => {
+      const curFavicon = faviconByEntries[f];
+      if (curFavicon) {
+        faviconNames.push(curFavicon.substring(curFavicon.lastIndexOf("/") + 1));
+      }
+    });
+  }
+  return faviconNames;
+};
+export {
+  createStaticMiddleware
+};

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

@@ -0,0 +1,31 @@
+import path from "path";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+async function getHtmlTemplates(pwd, routes) {
+  const htmls = await Promise.all(routes.map(async (route) => {
+    let html;
+    try {
+      var _this;
+      const htmlPath = path.join(pwd, route.entryPath);
+      html = (_this = await fileReader.readFile(htmlPath, "utf-8")) === null || _this === void 0 ? void 0 : _this.toString();
+    } catch (e) {
+    }
+    return [
+      route.entryName,
+      html
+    ];
+  }) || []);
+  const templates = Object.fromEntries(htmls);
+  return templates;
+}
+function createInjectHtml(pwd, routes) {
+  return async (c, next) => {
+    if (c.req.method.toUpperCase() === "GET" && !c.get("templates") && routes) {
+      const templates = await getHtmlTemplates(pwd, routes);
+      c.set("templates", templates);
+    }
+    return next();
+  };
+}
+export {
+  createInjectHtml
+};

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

@@ -0,0 +1,95 @@
+import { createServer, ServerResponse } from "node:http";
+import { writeReadableStreamToWritable } from "./polyfills/stream";
+import { installGlobals } from "./polyfills/install";
+installGlobals();
+const createWebRequest = (req, res) => {
+  const headerRecord = [];
+  const len = req.rawHeaders.length;
+  for (let i = 0; i < len; i += 2) {
+    headerRecord.push([
+      req.rawHeaders[i],
+      req.rawHeaders[i + 1]
+    ]);
+  }
+  const { method } = req;
+  const controller = new AbortController();
+  const init = {
+    method,
+    headers: headerRecord,
+    signal: controller.signal
+  };
+  res.on("close", () => controller.abort());
+  const url = `http://${req.headers.host}${req.url}`;
+  const request = new Request(url, init);
+  return request;
+};
+const sendResponse = async (response, res) => {
+  var _response_headers_get;
+  res.statusMessage = response.statusText;
+  res.statusCode = response.status;
+  const cookies = [];
+  for (const [key, value] of response.headers.entries()) {
+    if (key === "set-cookie") {
+      cookies.push(value);
+    } else {
+      res.setHeader(key, value);
+    }
+  }
+  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)) && res instanceof ServerResponse) {
+    res.flushHeaders();
+  }
+  if (response.body) {
+    await writeReadableStreamToWritable(response.body, res);
+  } else {
+    res.end();
+  }
+};
+const handleResponseError = (e, res) => {
+  const err = e instanceof 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: ${err.message}`);
+    res.destroy(err);
+  }
+};
+const getRequestListener = (handler) => {
+  return async (req, res) => {
+    try {
+      const request = createWebRequest(req, res);
+      const response = await handler(request, {
+        node: {
+          req,
+          res
+        }
+      });
+      if (!res.headersSent && !response.res) {
+        await sendResponse(response, res);
+      }
+    } catch (error) {
+      return handleResponseError(error, res);
+    }
+  };
+};
+const createNodeServer = (handleRequest) => {
+  const requestListener = getRequestListener(handleRequest);
+  const nodeServer = createServer(requestListener);
+  nodeServer.getRequestHandler = () => requestListener;
+  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,33 @@
+import { Request as NodeRequest, Response as NodeResponse, Headers as NodeHeaders } from "@web-std/fetch";
+import { TransformStream as NodeTransformStream, ReadableStream as NodeReadableStream } from "@web-std/stream";
+Object.defineProperty(NodeHeaders.prototype, "getSetCookie", {
+  value: function getSetCookie() {
+    const cookies = [];
+    this.forEach((value, name) => {
+      if (name.toLowerCase() === "set-cookie") {
+        cookies.push(value);
+      }
+    });
+    return cookies;
+  }
+});
+const installGlobals = () => {
+  if (!global.Headers) {
+    global.Headers = NodeHeaders;
+  }
+  if (!global.Request) {
+    global.Request = NodeRequest;
+  }
+  if (!global.Response) {
+    global.Response = NodeResponse;
+  }
+  if (!global.TransformStream) {
+    global.TransformStream = NodeTransformStream;
+  }
+  if (!global.ReadableStream) {
+    global.ReadableStream = NodeReadableStream;
+  }
+};
+export {
+  installGlobals
+};

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

@@ -0,0 +1,132 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { Stream } from "node:stream";
+import { ReadableStream } from "@web-std/stream";
+async function writeReadableStreamToWritable(stream, writable) {
+  const reader = stream.getReader();
+  const flushable = writable;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        writable.end();
+        break;
+      }
+      writable.write(value);
+      if (typeof flushable.flush === "function") {
+        flushable.flush();
+      }
+    }
+  } catch (error) {
+    writable.destroy(error);
+    throw error;
+  }
+}
+async function writeAsyncIterableToWritable(iterable, writable) {
+  try {
+    for await (const chunk of iterable) {
+      writable.write(chunk);
+    }
+    writable.end();
+  } catch (error) {
+    writable.destroy(error);
+    throw error;
+  }
+}
+async function readableStreamToString(stream, encoding) {
+  const reader = stream.getReader();
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    if (value) {
+      chunks.push(value);
+    }
+  }
+  return Buffer.concat(chunks).toString(encoding);
+}
+const createReadableStreamFromReadable = (source) => {
+  const pump = new StreamPump(source);
+  const stream = new ReadableStream(pump, pump);
+  return stream;
+};
+class StreamPump {
+  size(chunk) {
+    return (chunk === null || chunk === void 0 ? void 0 : chunk.byteLength) || 0;
+  }
+  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);
+  }
+  pull() {
+    this.resume();
+  }
+  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);
+  }
+  enqueue(chunk) {
+    if (this.controller) {
+      try {
+        const bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+        const 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();
+      }
+    }
+  }
+  pause() {
+    if (this.stream.pause) {
+      this.stream.pause();
+    }
+  }
+  resume() {
+    if (this.stream.readable && this.stream.resume) {
+      this.stream.resume();
+    }
+  }
+  close() {
+    if (this.controller) {
+      this.controller.close();
+      delete this.controller;
+    }
+  }
+  error(error) {
+    if (this.controller) {
+      this.controller.error(error);
+      delete this.controller;
+    }
+  }
+  constructor(stream) {
+    _define_property(this, "highWaterMark", void 0);
+    _define_property(this, "accumalatedSize", void 0);
+    _define_property(this, "stream", void 0);
+    _define_property(this, "controller", void 0);
+    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);
+  }
+}
+export {
+  createReadableStreamFromReadable,
+  readableStreamToString,
+  writeAsyncIterableToWritable,
+  writeReadableStreamToWritable
+};

package/dist/esm/base/constants.js

@@ -0,0 +1,29 @@
+const AGGRED_DIR = {
+  mock: "config/mock",
+  server: "server",
+  api: "api",
+  shared: "shared",
+  lambda: "lambda"
+};
+const 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 = {}));
+export {
+  AGGRED_DIR,
+  REPLACE_REG,
+  ServerReportTimings
+};

package/dist/esm/base/index.js

@@ -0,0 +1,32 @@
+import { ServerBase } from "./serverBase";
+import { createErrorHtml } from "./utils";
+import { AGGRED_DIR } from "./constants";
+import { httpCallBack2HonoMid, createNodeServer, loadServerEnv, connectMid2HonoMid, sendResponse, createStaticMiddleware, bindBFFHandler, registerMockHandlers, createInjectHtml } from "./adapters/node";
+import { favionFallbackMiddleware, bindDataHandlers, injectReporter, getRenderHandler, injectLogger, bindRenderHandler } from "./middlewares";
+function createServerBase(options) {
+  if (options == null) {
+    throw new Error("can not start server without options");
+  }
+  const server = new ServerBase(options);
+  return server;
+}
+export {
+  AGGRED_DIR,
+  bindBFFHandler,
+  bindDataHandlers,
+  bindRenderHandler,
+  connectMid2HonoMid,
+  createErrorHtml,
+  createInjectHtml,
+  createNodeServer,
+  createServerBase,
+  createStaticMiddleware,
+  favionFallbackMiddleware,
+  getRenderHandler,
+  httpCallBack2HonoMid,
+  injectLogger,
+  injectReporter,
+  loadServerEnv,
+  registerMockHandlers,
+  sendResponse
+};

package/dist/esm/base/middlewares/customServer/base.js

@@ -0,0 +1,91 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { getCookie } from "hono/cookie";
+import { getHost } from "../../utils";
+function createBaseHookContext(c, logger, metrics) {
+  return {
+    request: new BaseHookRequest(c),
+    response: new BaseHookResponse(c),
+    logger,
+    metrics
+  };
+}
+class BaseHookRequest {
+  get url() {
+    return this.req.url;
+  }
+  get host() {
+    return getHost(this.req.raw);
+  }
+  get pathname() {
+    return this.req.path;
+  }
+  get query() {
+    return this.req.query();
+  }
+  get headers() {
+    return this.req.header();
+  }
+  get cookies() {
+    return {
+      // FIXME: ModernRequest Type Error
+      get: (key) => {
+        return getCookie(this.c, key);
+      }
+    };
+  }
+  get cookie() {
+    return this.req.header("cookie");
+  }
+  constructor(c) {
+    _define_property(this, "req", void 0);
+    _define_property(this, "c", void 0);
+    this.c = c;
+    this.req = c.req;
+  }
+}
+class BaseHookResponse {
+  get(key) {
+    return this.c.res.headers.get(key);
+  }
+  set(key, value) {
+    if ([
+      "set-cookie",
+      "Set-Cookie"
+    ].includes(key)) {
+      this.c.header(key, value.toString(), {
+        append: true
+      });
+    } else {
+      this.c.header(key, value.toString());
+    }
+  }
+  status(code) {
+    this.c.status(code);
+  }
+  get cookies() {
+    const setCookie = (key, value) => {
+      this.c.header("set-cookie", `${key}=${value}`, {
+        append: true
+      });
+    };
+    const clearCookie = () => {
+      this.c.header("set-cookie", void 0);
+    };
+    return {
+      set: setCookie,
+      clear: clearCookie
+    };
+  }
+  raw(body, options) {
+    this.c.res = this.c.newResponse(body, options);
+    this.private_overrided = true;
+  }
+  constructor(c) {
+    _define_property(this, "private_overrided", false);
+    _define_property(this, "c", void 0);
+    this.c = c;
+  }
+}
+export {
+  createBaseHookContext
+};

package/dist/esm/base/middlewares/customServer/context.js

@@ -0,0 +1,51 @@
+import { RouterAPI } from "./routerApi";
+import { TemplateApi } from "./template";
+import { createBaseHookContext } from "./base";
+function createAfterMatchCtx(c, entryName, logger, metrics) {
+  const baseContext = createBaseHookContext(c, logger, metrics);
+  return {
+    ...baseContext,
+    router: new RouterAPI(entryName)
+  };
+}
+async function createAfterRenderCtx(c, logger, metrics) {
+  const baseContext = createBaseHookContext(c, logger, metrics);
+  const resBody = await c.res.text();
+  return {
+    ...baseContext,
+    template: new TemplateApi(resBody)
+  };
+}
+function createCustomMiddlewaresCtx(c, logger, metrics) {
+  var _c_env_node, _c_env_node1;
+  const baseContext = createBaseHookContext(c, logger, metrics);
+  const reporter = c.get("reporter");
+  return {
+    ...baseContext,
+    reporter,
+    response: {
+      ...baseContext.response,
+      locals: {}
+    },
+    source: {
+      req: (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req,
+      res: (_c_env_node1 = c.env.node) === null || _c_env_node1 === void 0 ? void 0 : _c_env_node1.res
+    }
+  };
+}
+function createAfterStreamingRenderContext(c, logger, route, metrics) {
+  const baseContext = createBaseHookContext(c, logger, metrics);
+  return (chunk) => {
+    return {
+      ...baseContext,
+      route,
+      chunk
+    };
+  };
+}
+export {
+  createAfterMatchCtx,
+  createAfterRenderCtx,
+  createAfterStreamingRenderContext,
+  createCustomMiddlewaresCtx
+};