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

package/dist/cjs/base/utils/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./env"), module.exports);
+__reExport(utils_exports, require("./request"), module.exports);
+__reExport(utils_exports, require("./serverConfig"), module.exports);
+__reExport(utils_exports, require("./debug"), module.exports);
+__reExport(utils_exports, require("./transformStream"), module.exports);
+__reExport(utils_exports, require("./middlewareCollector"), module.exports);
+__reExport(utils_exports, require("./error"), module.exports);
+__reExport(utils_exports, require("./warmup"), module.exports);
+__reExport(utils_exports, require("./entry"), module.exports);
+__reExport(utils_exports, require("./path"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./env"),
+  ...require("./request"),
+  ...require("./serverConfig"),
+  ...require("./debug"),
+  ...require("./transformStream"),
+  ...require("./middlewareCollector"),
+  ...require("./error"),
+  ...require("./warmup"),
+  ...require("./entry"),
+  ...require("./path")
+});

package/dist/cjs/base/utils/middlewareCollector.js

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middlewareCollector_exports = {};
+__export(middlewareCollector_exports, {
+  createMiddlewareCollecter: () => createMiddlewareCollecter,
+  mergeExtension: () => mergeExtension
+});
+module.exports = __toCommonJS(middlewareCollector_exports);
+const mergeExtension = (users) => {
+  const output = [];
+  return {
+    middleware: output.concat(users)
+  };
+};
+const createMiddlewareCollecter = () => {
+  const webMiddlewares = [];
+  const apiMiddlewares = [];
+  const addWebMiddleware = (input) => {
+    webMiddlewares.push(input);
+  };
+  const addAPIMiddleware = (input) => {
+    apiMiddlewares.push(input);
+  };
+  const getMiddlewares = () => ({
+    web: webMiddlewares,
+    api: apiMiddlewares
+  });
+  return {
+    getMiddlewares,
+    addWebMiddleware,
+    addAPIMiddleware
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMiddlewareCollecter,
+  mergeExtension
+});

package/dist/cjs/base/utils/path.js

@@ -0,0 +1,46 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var path_exports = {};
+__export(path_exports, {
+  getPathModule: () => getPathModule
+});
+module.exports = __toCommonJS(path_exports);
+async function getPathModule() {
+  let path;
+  try {
+    path = await Promise.resolve().then(() => __toESM(require("path")));
+  } catch (_) {
+    path = await Promise.resolve().then(() => __toESM(require("path-browserify")));
+  }
+  return path;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPathModule
+});

package/dist/cjs/base/utils/request.js

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var request_exports = {};
+__export(request_exports, {
+  getHost: () => getHost,
+  getPathname: () => getPathname,
+  parseHeaders: () => parseHeaders,
+  parseQuery: () => parseQuery
+});
+module.exports = __toCommonJS(request_exports);
+function parseQuery(request) {
+  const { url } = request;
+  const q = url.split("?")[1];
+  const query = {};
+  if (q) {
+    q.split("&").forEach((item) => {
+      const [key, value] = item.split("=");
+      query[key] = value;
+    });
+  }
+  return query;
+}
+function parseHeaders(request) {
+  const headersData = {};
+  request.headers.forEach((value, key) => {
+    headersData[key] = value;
+  });
+  return headersData;
+}
+function getPathname(request) {
+  const match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
+  return match ? match[1] : "/";
+}
+function getHost(request) {
+  const { headers } = request;
+  let host = headers.get("X-Forwarded-Host");
+  if (!host) {
+    host = headers.get("Host");
+  }
+  host = (host === null || host === void 0 ? void 0 : host.split(/\s*,\s*/, 1)[0]) || "undefined";
+  return host;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getHost,
+  getPathname,
+  parseHeaders,
+  parseQuery
+});

package/dist/cjs/base/utils/serverConfig.js

@@ -0,0 +1,71 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serverConfig_exports = {};
+__export(serverConfig_exports, {
+  getServerConfigPath: () => getServerConfigPath,
+  loadConfig: () => loadConfig,
+  requireConfig: () => requireConfig
+});
+module.exports = __toCommonJS(serverConfig_exports);
+var import_utils = require("@modern-js/utils");
+var import_merge_deep = __toESM(require("merge-deep"));
+var import_path = require("./path");
+const getServerConfigPath = async (distDirectory, serverConfigFile = import_utils.DEFAULT_SERVER_CONFIG) => {
+  const path = await (0, import_path.getPathModule)();
+  const serverConfigPath = path.join(distDirectory, serverConfigFile);
+  return `${serverConfigPath}.js`;
+};
+const requireConfig = (serverConfigPath) => {
+  if (import_utils.fs.pathExistsSync(serverConfigPath)) {
+    return (0, import_utils.compatRequire)(serverConfigPath);
+  }
+  return {};
+};
+const loadConfig = ({ cliConfig, serverConfig, resolvedConfigPath }) => {
+  let config = null;
+  if (process.env.NODE_ENV === "production") {
+    const resolvedConfig = requireConfig(resolvedConfigPath);
+    config = (0, import_merge_deep.default)({
+      ...resolvedConfig,
+      plugins: []
+    }, serverConfig, cliConfig);
+  } else {
+    config = (0, import_merge_deep.default)({
+      ...cliConfig,
+      plugins: []
+    }, serverConfig);
+  }
+  return config;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getServerConfigPath,
+  loadConfig,
+  requireConfig
+});

package/dist/cjs/base/utils/transformStream.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transformStream_exports = {};
+__export(transformStream_exports, {
+  createTransformStream: () => createTransformStream
+});
+module.exports = __toCommonJS(transformStream_exports);
+function createTransformStream(fn) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  return new TransformStream({
+    async transform(chunk, controller) {
+      const content = decoder.decode(chunk);
+      const newContent = await fn(content);
+      controller.enqueue(encoder.encode(newContent));
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTransformStream
+});

package/dist/cjs/base/utils/warmup.js

@@ -0,0 +1,43 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var warmup_exports = {};
+__export(warmup_exports, {
+  warmup: () => warmup
+});
+module.exports = __toCommonJS(warmup_exports);
+function warmup(bundles) {
+  bundles.forEach((bundle) => {
+    bundle && Promise.resolve().then(() => __toESM(require(bundle))).catch((_) => {
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  warmup
+});

package/dist/cjs/core/hono.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hono_exports = {};
+module.exports = __toCommonJS(hono_exports);

package/dist/cjs/core/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var core_exports = {};
+module.exports = __toCommonJS(core_exports);
+__reExport(core_exports, require("./plugin"), module.exports);
+__reExport(core_exports, require("./loadPlugins"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./plugin"),
+  ...require("./loadPlugins")
+});

package/dist/cjs/{loadPlugins.js → core/loadPlugins.js}

@@ -22,7 +22,7 @@ __export(loadPlugins_exports, {
 });
 module.exports = __toCommonJS(loadPlugins_exports);
 var import_utils = require("@modern-js/utils");
-var import_plugin = require("./plugin");
+var import_plugin = require("../core/plugin");
 const resolvePlugin = (p, appDirectory) => {
   const isPluginInstance = typeof p !== "string";
   if (isPluginInstance) {

package/dist/cjs/{plugin.js → core/plugin.js}

@@ -35,10 +35,9 @@ const prepare = (0, import_plugin.createWaterfall)();
 const prepareLoaderHandler = (0, import_plugin.createAsyncPipeline)();
 const prepareWebServer = (0, import_plugin.createAsyncPipeline)();
 const prepareApiServer = (0, import_plugin.createAsyncPipeline)();
-const onApiChange = (0, import_plugin.createWaterfall)();
+const onApiChange = (0, import_plugin.createAsyncWaterfall)();
 const repack = (0, import_plugin.createWaterfall)();
 const beforeServerInit = (0, import_plugin.createAsyncWaterfall)();
-const afterServerInit = (0, import_plugin.createAsyncWaterfall)();
 const setupCompiler = (0, import_plugin.createParallelWorkflow)();
 const beforeRouteSet = (0, import_plugin.createAsyncPipeline)();
 const afterRouteSet = (0, import_plugin.createAsyncPipeline)();
@@ -82,7 +81,6 @@ const serverHooks = {
   repack,
   onApiChange,
   beforeServerInit,
-  afterServerInit,
   setupCompiler,
   beforeRouteSet,
   afterRouteSet,

package/dist/cjs/core/render.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var render_exports = {};
+module.exports = __toCommonJS(render_exports);

package/dist/cjs/core/server.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+module.exports = __toCommonJS(server_exports);
+__reExport(server_exports, require("./hono"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./hono")
+});

package/dist/cjs/index.js

@@ -15,14 +15,16 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
 module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./plugin"), module.exports);
+__reExport(src_exports, require("./core/plugin"), module.exports);
+__reExport(src_exports, require("./core/render"), module.exports);
 __reExport(src_exports, require("@modern-js/plugin"), module.exports);
-__reExport(src_exports, require("./loadPlugins"), module.exports);
+__reExport(src_exports, require("./core/loadPlugins"), module.exports);
 __reExport(src_exports, require("./types/config"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./plugin"),
+  ...require("./core/plugin"),
+  ...require("./core/render"),
   ...require("@modern-js/plugin"),
-  ...require("./loadPlugins"),
+  ...require("./core/loadPlugins"),
   ...require("./types/config")
 });

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

@@ -0,0 +1,45 @@
+import { isWebOnly } from "@modern-js/utils";
+import { getRenderHandler } from "../../../base/middlewares";
+import { createMiddlewareCollecter, getRuntimeEnv } from "../../utils";
+const bindBFFHandler = async (server, options) => {
+  const prefix = options.config.bff.prefix || "/api";
+  const { enableHandleWeb } = options.config.bff;
+  const { httpMethodDecider } = options.config.bff;
+  const runtimeEnv = getRuntimeEnv();
+  if (runtimeEnv !== "node") {
+    return;
+  }
+  const { getMiddlewares, ...collector } = createMiddlewareCollecter();
+  const { runner } = server;
+  await runner.gather(collector);
+  const webOnly = await isWebOnly();
+  let handler;
+  const renderHandler = getRenderHandler(options);
+  if (webOnly) {
+    handler = async (c, next) => {
+      c.body("");
+      await next();
+    };
+  } else {
+    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/base/adapters/node/hono.js

@@ -0,0 +1,37 @@
+const httpCallBack2HonoMid = (handler) => {
+  return async (context, next) => {
+    const { req, res } = context.env.node;
+    req.__honoRequest = context.req;
+    req.__templates = context.get("templates") || {};
+    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/base/adapters/node/index.js

@@ -0,0 +1,6 @@
+export * from "./loadServer";
+export * from "./hono";
+export * from "./node";
+export * from "./bff";
+export * from "./middlewares";
+export * from "./polyfills";

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

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