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

package/dist/esm/core/plugin.js

@@ -0,0 +1,59 @@
+import { createContext, createAsyncManager, createAsyncPipeline, createAsyncWaterfall, createParallelWorkflow, createWaterfall } from "@modern-js/plugin";
+var gather = createParallelWorkflow();
+var config = createWaterfall();
+var prepare = createWaterfall();
+var prepareWebServer = createAsyncPipeline();
+var prepareApiServer = createAsyncPipeline();
+var onApiChange = createAsyncWaterfall();
+var repack = createWaterfall();
+var beforeServerInit = createAsyncWaterfall();
+var afterMatch = createAsyncPipeline();
+var afterRender = createAsyncPipeline();
+var afterStreamingRender = createAsyncPipeline();
+var reset = createParallelWorkflow();
+var AppContext = createContext({});
+var setAppContext = function(value) {
+  return AppContext.set(value);
+};
+var ConfigContext = createContext({});
+var useConfigContext = function() {
+  return ConfigContext.use().value;
+};
+var useAppContext = function() {
+  return AppContext.use().value;
+};
+var pluginAPI = {
+  useAppContext,
+  useConfigContext,
+  setAppContext
+};
+var serverHooks = {
+  // server hook
+  gather,
+  config,
+  prepare,
+  prepareWebServer,
+  prepareApiServer,
+  repack,
+  onApiChange,
+  beforeServerInit,
+  afterMatch,
+  afterRender,
+  afterStreamingRender,
+  reset
+};
+var createServerManager = function() {
+  return createAsyncManager(serverHooks, pluginAPI);
+};
+var serverManager = createServerManager();
+var createPlugin = serverManager.createPlugin;
+export {
+  AppContext,
+  ConfigContext,
+  createPlugin,
+  createServerManager,
+  serverManager,
+  setAppContext,
+  useAppContext,
+  useConfigContext
+};

package/dist/esm/index.js

@@ -1,4 +1,5 @@
-export * from "./plugin";
+export * from "./core/plugin";
+export * from "./core/render";
 export * from "@modern-js/plugin";
-export * from "./loadPlugins";
+export * from "./core/loadPlugins";
 export * from "./types/config";

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

@@ -0,0 +1,46 @@
+import { isWebOnly } from "@modern-js/utils";
+import { getRenderHandler } from "../../../base/middlewares";
+import { createMiddlewareCollecter, getRuntimeEnv } from "../../utils";
+const bindBFFHandler = async (server, options) => {
+  var _options_config_bff, _options_config, _options_config_bff1, _options_config1, _options_config_bff2, _options_config2;
+  const prefix = (options === null || options === void 0 ? void 0 : (_options_config = options.config) === null || _options_config === void 0 ? void 0 : (_options_config_bff = _options_config.bff) === null || _options_config_bff === void 0 ? void 0 : _options_config_bff.prefix) || "/api";
+  const enableHandleWeb = options === null || options === void 0 ? void 0 : (_options_config1 = options.config) === null || _options_config1 === void 0 ? void 0 : (_options_config_bff1 = _options_config1.bff) === null || _options_config_bff1 === void 0 ? void 0 : _options_config_bff1.enableHandleWeb;
+  const httpMethodDecider = options === null || options === void 0 ? void 0 : (_options_config2 = options.config) === null || _options_config2 === void 0 ? void 0 : (_options_config_bff2 = _options_config2.bff) === null || _options_config_bff2 === void 0 ? void 0 : _options_config_bff2.httpMethodDecider;
+  const runtimeEnv = getRuntimeEnv();
+  if (runtimeEnv !== "node") {
+    return;
+  }
+  const { getMiddlewares, ...collector } = createMiddlewareCollecter();
+  const { runner } = server;
+  await runner.gather(collector);
+  const webOnly = await isWebOnly();
+  let handler;
+  if (webOnly) {
+    handler = async (c, next) => {
+      c.body("");
+      await next();
+    };
+  } else {
+    const renderHandler = enableHandleWeb ? await getRenderHandler(options) : null;
+    handler = await server.runner.prepareApiServer({
+      pwd: options.pwd,
+      prefix,
+      render: renderHandler,
+      httpMethodDecider
+    }, {
+      onLast: () => null
+    });
+  }
+  if (handler) {
+    server.all(`*`, (c, next) => {
+      if (!c.req.path.startsWith(prefix) && !enableHandleWeb) {
+        return next();
+      } else {
+        return handler(c, next);
+      }
+    });
+  }
+};
+export {
+  bindBFFHandler
+};

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

@@ -0,0 +1,38 @@
+const httpCallBack2HonoMid = (handler) => {
+  return async (context, next) => {
+    const { req, res } = context.env.node;
+    req.__honoRequest = context.req;
+    req.__templates = context.get("templates") || {};
+    req.__serverManifest = context.get("serverManifest") || {};
+    await handler(req, res);
+    if (res.headersSent) {
+      context.finalized = true;
+    } else {
+      await next();
+    }
+  };
+};
+const noop = () => {
+};
+const connectMid2HonoMid = (handler) => {
+  return async (context, next) => {
+    return new Promise((resolve, reject) => {
+      const { req, res } = context.env.node;
+      if (handler.length < 3) {
+        resolve(handler(req, res, noop));
+      } else {
+        handler(req, res, (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(next());
+          }
+        });
+      }
+    });
+  };
+};
+export {
+  connectMid2HonoMid,
+  httpCallBack2HonoMid
+};

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

@@ -0,0 +1,20 @@
+import { loadServerEnv } from "./loadServer";
+import { httpCallBack2HonoMid, connectMid2HonoMid } from "./hono";
+import { createNodeServer, sendResponse, createWebRequest } from "./node";
+import { bindBFFHandler } from "./bff";
+import { createStaticMiddleware, registerMockHandlers, injectServerManifest, injectTemplates, getHtmlTemplates, getServerManifest } from "./middlewares";
+export {
+  bindBFFHandler,
+  connectMid2HonoMid,
+  createNodeServer,
+  createStaticMiddleware,
+  createWebRequest,
+  getHtmlTemplates,
+  getServerManifest,
+  httpCallBack2HonoMid,
+  injectServerManifest,
+  injectTemplates,
+  loadServerEnv,
+  registerMockHandlers,
+  sendResponse
+};

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

@@ -0,0 +1,22 @@
+import path from "path";
+import { fs, dotenv, dotenvExpand } from "@modern-js/utils";
+async function loadServerEnv(options) {
+  const { pwd } = options;
+  const serverEnv = process.env.MODERN_ENV;
+  const defaultEnvPath = path.resolve(pwd, `.env`);
+  const serverEnvPath = path.resolve(pwd, `.env.${serverEnv}`);
+  for (const envPath of [
+    serverEnvPath,
+    defaultEnvPath
+  ]) {
+    if (await fs.pathExists(envPath) && !(await fs.stat(envPath)).isDirectory()) {
+      const envConfig = dotenv.config({
+        path: envPath
+      });
+      dotenvExpand(envConfig);
+    }
+  }
+}
+export {
+  loadServerEnv
+};

package/dist/esm-node/base/adapters/node/middlewares/index.js

@@ -0,0 +1,4 @@
+export * from "./mock";
+export * from "./serverStatic";
+export * from "./templates";
+export * from "./serverManifest";

package/dist/esm-node/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-node/base/adapters/node/middlewares/serverManifest.js

@@ -0,0 +1,55 @@
+import path from "path";
+import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY } from "@modern-js/utils";
+async function getServerManifest(pwd, routes) {
+  const loaderBundles = {};
+  const renderBundles = {};
+  await Promise.all(routes.map(async (route) => {
+    const entryName = route.entryName || MAIN_ENTRY_NAME;
+    const loaderBundlePath = path.join(pwd, SERVER_BUNDLE_DIRECTORY, `${entryName}-server-loaders.js`);
+    const renderBundlePath = path.join(pwd, route.bundle || "");
+    const dynamicImport = (filePath) => {
+      try {
+        const module = require(filePath);
+        return Promise.resolve(module);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    await Promise.allSettled([
+      dynamicImport(loaderBundlePath),
+      dynamicImport(renderBundlePath)
+    ]).then((results) => {
+      const { status: loaderStatus } = results[0];
+      if (loaderStatus === "fulfilled") {
+        loaderBundles[entryName] = results[0].value;
+      }
+      const { status: renderStatus } = results[1];
+      if (renderStatus === "fulfilled") {
+        renderBundles[entryName] = results[1].value;
+      }
+    });
+  }));
+  const loadableUri = path.join(pwd, LOADABLE_STATS_FILE);
+  const loadableStats = await import(loadableUri).catch((_) => ({}));
+  const routesManifestUri = path.join(pwd, ROUTE_MANIFEST_FILE);
+  const routeManifest = await import(routesManifestUri).catch((_) => ({}));
+  return {
+    loaderBundles,
+    renderBundles,
+    loadableStats,
+    routeManifest
+  };
+}
+function injectServerManifest(pwd, routes) {
+  return async (c, next) => {
+    if (routes && !c.get("serverManifest")) {
+      const serverManifest = await getServerManifest(pwd, routes);
+      c.set("serverManifest", serverManifest);
+    }
+    await next();
+  };
+}
+export {
+  getServerManifest,
+  injectServerManifest
+};

package/dist/esm-node/base/adapters/node/middlewares/serverPublic.js

@@ -0,0 +1,33 @@
+import path from "path";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+import { getMimeType } from "hono/utils/mime";
+import { sortRoutes } from "../../../utils";
+function createPublicMiddleware({ pwd, routes }) {
+  return async (c, next) => {
+    const route = matchRoute(c.req, routes);
+    if (route) {
+      const { entryPath } = route;
+      const filename = path.join(pwd, entryPath);
+      const data = await fileReader.readFile(filename, "buffer");
+      const mimeType = getMimeType(filename);
+      if (data !== null) {
+        if (mimeType) {
+          c.header("Content-Type", mimeType);
+        }
+        return c.body(data, 200);
+      }
+    }
+    return await next();
+  };
+}
+function matchRoute(req, routes) {
+  for (const route of routes.sort(sortRoutes)) {
+    if (!route.isSSR && !route.isApi && route.entryPath.startsWith("public") && req.path.startsWith(route.urlPath)) {
+      return route;
+    }
+  }
+  return void 0;
+}
+export {
+  createPublicMiddleware
+};

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

@@ -0,0 +1,75 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+import { getMimeType } from "hono/utils/mime";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+import { createErrorHtml } from "../../../utils";
+import { createPublicMiddleware } from "./serverPublic";
+function createStaticMiddleware(options) {
+  const { pwd, routes } = 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.join(pwd, pathname.replace(prefix, () => ""));
+      if (!await fs.pathExists(filepath)) {
+        return c.html(createErrorHtml(404), 404);
+      }
+      const mimeType = getMimeType(filepath);
+      if (mimeType) {
+        c.header("Content-Type", mimeType);
+      }
+      const stat = await fs.lstat(filepath);
+      const { size } = stat;
+      const chunk = await fileReader.readFile(filepath, "buffer");
+      c.header("Content-Length", String(size));
+      return c.body(chunk, 200);
+    } else {
+      return createPublicMiddleware({
+        pwd,
+        routes: routes || []
+      })(c, next);
+    }
+  };
+}
+const prepareFavicons = (favicon, faviconByEntries) => {
+  const faviconNames = [];
+  if (favicon && typeof favicon === "string") {
+    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-node/base/adapters/node/middlewares/templates.js

@@ -0,0 +1,32 @@
+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 injectTemplates(pwd, routes) {
+  return async (c, next) => {
+    if (routes && !c.get("templates")) {
+      const templates = await getHtmlTemplates(pwd, routes);
+      c.set("templates", templates);
+    }
+    await next();
+  };
+}
+export {
+  getHtmlTemplates,
+  injectTemplates
+};

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

@@ -0,0 +1,101 @@
+import { createServer, ServerResponse } from "node:http";
+import { createReadableStreamFromReadable, writeReadableStreamToWritable } from "./polyfills/stream";
+import { installGlobals } from "./polyfills/install";
+installGlobals();
+const createWebRequest = (req, res) => {
+  var _req_url;
+  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());
+  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";
+  }
+  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 = (requestHandler) => {
+  const requestListener = getRequestListener(requestHandler);
+  const nodeServer = createServer(requestListener);
+  nodeServer.getRequestListener = () => requestListener;
+  nodeServer.getRequestHandler = () => requestHandler;
+  return nodeServer;
+};
+export {
+  createNodeServer,
+  createWebRequest,
+  sendResponse
+};

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

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

package/dist/esm-node/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() {
+      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.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
+};