@modern-js/server-core 2.53.0 → 2.54.1

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

@@ -0,0 +1,10 @@
+import { loadServerEnv } from "./loadEnv";
+import { loadServerPlugins } from "./loadPlugin";
+import { loadServerConfig } from "./loadConfig";
+import { loadCacheConfig } from "./loadCache";
+export {
+  loadCacheConfig,
+  loadServerConfig,
+  loadServerEnv,
+  loadServerPlugins
+};

package/dist/esm-node/adapters/node/helper/loadCache.js

@@ -0,0 +1,19 @@
+import path from "path";
+import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
+const CACHE_FILENAME = "cache";
+function loadCacheConfig(pwd) {
+  const serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
+  const mod = requireExistModule(serverCacheFilepath, {
+    interop: false
+  });
+  if (mod === null || mod === void 0 ? void 0 : mod.cacheOption) {
+    return {
+      strategy: mod.cacheOption,
+      container: mod.customContainer
+    };
+  }
+  return void 0;
+}
+export {
+  loadCacheConfig
+};

package/dist/esm-node/adapters/node/helper/loadConfig.js

@@ -0,0 +1,31 @@
+import path from "path";
+import { compatRequire, fs, DEFAULT_SERVER_CONFIG, requireExistModule } from "@modern-js/utils";
+const requireConfig = (serverConfigPath) => {
+  if (fs.pathExistsSync(serverConfigPath)) {
+    return compatRequire(serverConfigPath);
+  }
+  return void 0;
+};
+function loadServerConfigNew(serverConfigPath) {
+  const mod = requireExistModule(serverConfigPath);
+  if (mod) {
+    return mod;
+  }
+  return void 0;
+}
+function loadServerConfigOld(pwd, configFile) {
+  const serverConfigPath = path.join(pwd, `${configFile}.js`);
+  const serverConfig = requireConfig(serverConfigPath);
+  return serverConfig;
+}
+function loadServerConfig(pwd, oldServerFile = DEFAULT_SERVER_CONFIG, newServerConfigPath) {
+  const newServerConfig = newServerConfigPath && loadServerConfigNew(newServerConfigPath);
+  if (newServerConfig) {
+    return newServerConfig;
+  }
+  const oldServerConfig = loadServerConfigOld(pwd, oldServerFile);
+  return oldServerConfig;
+}
+export {
+  loadServerConfig
+};

package/dist/esm-node/adapters/node/helper/loadPlugin.js

@@ -0,0 +1,15 @@
+import { compatRequire, tryResolve } from "@modern-js/utils";
+function resolveServerPlugin(plugin, appDirectory) {
+  const { name, options } = plugin;
+  const pluginPath = tryResolve(name, appDirectory);
+  const module = compatRequire(pluginPath);
+  const pluginInstance = module(options);
+  return pluginInstance;
+}
+function loadServerPlugins(serverPlugins, appDirectory) {
+  const instances = serverPlugins.map((plugin) => resolveServerPlugin(plugin, appDirectory));
+  return instances;
+}
+export {
+  loadServerPlugins
+};

package/dist/{esm/base → esm-node}/adapters/node/index.js

@@ -1,21 +1,21 @@
-import { loadServerEnv } from "./loadServer";
 import { httpCallBack2HonoMid, connectMid2HonoMid } from "./hono";
 import { createNodeServer, sendResponse, createWebRequest, writeReadableStreamToWritable } from "./node";
-import { bindBFFHandler } from "./bff";
-import { createStaticMiddleware, registerMockHandlers, injectServerManifest, injectTemplates, getHtmlTemplates, getServerManifest } from "./middlewares";
+import { serverStaticPlugin, injectResourcePlugin, getHtmlTemplates, getServerManifest, injectNodeSeverPlugin } from "./plugins";
+import { loadServerPlugins, loadServerEnv, loadServerConfig, loadCacheConfig } from "./helper";
 export {
-  bindBFFHandler,
   connectMid2HonoMid,
   createNodeServer,
-  createStaticMiddleware,
   createWebRequest,
   getHtmlTemplates,
   getServerManifest,
   httpCallBack2HonoMid,
-  injectServerManifest,
-  injectTemplates,
+  injectNodeSeverPlugin,
+  injectResourcePlugin,
+  loadCacheConfig,
+  loadServerConfig,
   loadServerEnv,
-  registerMockHandlers,
+  loadServerPlugins,
   sendResponse,
+  serverStaticPlugin,
   writeReadableStreamToWritable
 };

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

@@ -0,0 +1,3 @@
+export * from "./static";
+export * from "./resource";
+export * from "./nodeServer";

package/dist/esm-node/adapters/node/plugins/nodeServer.js

@@ -0,0 +1,14 @@
+const injectNodeSeverPlugin = ({ nodeServer }) => ({
+  name: "@modern-js/plugin-inject-node-server",
+  setup(api) {
+    const appContext = api.useAppContext();
+    api.setAppContext({
+      ...appContext,
+      nodeServer
+    });
+    return {};
+  }
+});
+export {
+  injectNodeSeverPlugin
+};

package/dist/esm-node/{base/adapters/node/middlewares/serverManifest.js → adapters/node/plugins/resource.js}

@@ -1,5 +1,32 @@
 import path from "path";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
 import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, fs } from "@modern-js/utils";
+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();
+  };
+}
 const dynamicImport = (filePath) => {
   try {
     const module = require(filePath);
@@ -50,7 +77,28 @@ function injectServerManifest(pwd, routes) {
     await next();
   };
 }
+const injectResourcePlugin = () => ({
+  name: "@modern-js/plugin-inject-resource",
+  setup(api) {
+    return {
+      async prepare() {
+        const { middlewares, routes, distDirectory: pwd } = api.useAppContext();
+        middlewares.push({
+          name: "inject-server-manifest",
+          handler: injectServerManifest(pwd, routes)
+        });
+        middlewares.push({
+          name: "inject-html",
+          handler: injectTemplates(pwd, routes)
+        });
+      }
+    };
+  }
+});
 export {
+  getHtmlTemplates,
   getServerManifest,
-  injectServerManifest
+  injectResourcePlugin,
+  injectServerManifest,
+  injectTemplates
 };

package/dist/esm-node/{base/adapters/node/middlewares/serverStatic.js → adapters/node/plugins/static.js}

@@ -2,7 +2,57 @@ 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 { createPublicMiddleware } from "./serverPublic";
+import { sortRoutes } from "../../../utils";
+const serverStaticPlugin = () => ({
+  name: "@modern-js/plugin-server-static",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares, distDirectory: pwd, routes } = api.useAppContext();
+        const config = api.useConfigContext();
+        const serverStaticMiddleware = createStaticMiddleware({
+          pwd,
+          routes,
+          output: config.output || {},
+          html: config.html || {}
+        });
+        middlewares.push({
+          name: "server-static",
+          handler: serverStaticMiddleware
+        });
+      }
+    };
+  }
+});
+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);
+        }
+        Object.entries(route.responseHeaders || {}).forEach(([k, v]) => {
+          c.header(k, v);
+        });
+        return c.body(data, 200);
+      }
+    }
+    return await next();
+  };
+}
+function matchRoute(req, routes) {
+  for (const route of routes.sort(sortRoutes)) {
+    if (!route.isSSR && route.entryPath.startsWith("public") && req.path.startsWith(route.urlPath)) {
+      return route;
+    }
+  }
+  return void 0;
+}
 function createStaticMiddleware(options) {
   const { pwd, routes } = options;
   const prefix = options.output.assetPrefix || "/";
@@ -70,5 +120,7 @@ const prepareFavicons = (favicon, faviconByEntries) => {
   return faviconNames;
 };
 export {
-  createStaticMiddleware
+  createPublicMiddleware,
+  createStaticMiddleware,
+  serverStaticPlugin
 };

package/dist/esm-node/{base/constants.js → constants.js}

@@ -23,9 +23,11 @@ var ServerReportTimings;
   ServerReportTimings2["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
 })(ServerReportTimings || (ServerReportTimings = {}));
 const X_RENDER_CACHE = "x-render-cache";
+const X_MODERNJS_RENDER = "x-modernjs-render";
 export {
   AGGRED_DIR,
   REPLACE_REG,
   ServerReportTimings,
+  X_MODERNJS_RENDER,
   X_RENDER_CACHE
 };

package/dist/esm-node/index.js

@@ -1,5 +1,17 @@
-export * from "./core/plugin";
-export * from "./core/render";
+import { createErrorHtml, onError, ErrorDigest } from "./utils";
+import { AGGRED_DIR } from "./constants";
+import { createServerBase } from "./serverBase";
+import { PluginManager } from "./pluginManager";
+export * from "./plugins";
+export * from "./types/plugin";
+export * from "./types/render";
 export * from "@modern-js/plugin";
-export * from "./core/loadPlugins";
 export * from "./types/config";
+export {
+  AGGRED_DIR,
+  ErrorDigest,
+  PluginManager,
+  createErrorHtml,
+  createServerBase,
+  onError
+};

package/dist/esm-node/pluginManager.js

@@ -0,0 +1,82 @@
+import { _ as _class_private_field_get } from "@swc/helpers/_/_class_private_field_get";
+import { _ as _class_private_field_init } from "@swc/helpers/_/_class_private_field_init";
+import { _ as _class_private_field_set } from "@swc/helpers/_/_class_private_field_set";
+import { _ as _class_private_method_get } from "@swc/helpers/_/_class_private_method_get";
+import { _ as _class_private_method_init } from "@swc/helpers/_/_class_private_method_init";
+import { createAsyncManager, createAsyncPipeline, createAsyncWaterfall, createContext, createParallelWorkflow } from "@modern-js/plugin";
+import { loadConfig } from "./utils";
+var _appContext = /* @__PURE__ */ new WeakMap(), _plugins = /* @__PURE__ */ new WeakMap(), _options = /* @__PURE__ */ new WeakMap(), _configContext = /* @__PURE__ */ new WeakMap(), _createCoreManager = /* @__PURE__ */ new WeakSet(), _initConfigContext = /* @__PURE__ */ new WeakSet();
+class PluginManager {
+  async init() {
+    const coreManager = _class_private_method_get(this, _createCoreManager, createCoreManager).call(this);
+    const runner = await coreManager.init();
+    await _class_private_method_get(this, _initConfigContext, initConfigContext).call(this, runner);
+    return runner;
+  }
+  addPlugins(plugins) {
+    _class_private_field_get(this, _plugins).push(...plugins);
+  }
+  constructor(options) {
+    _class_private_method_init(this, _createCoreManager);
+    _class_private_method_init(this, _initConfigContext);
+    _class_private_field_init(this, _appContext, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_init(this, _plugins, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_init(this, _options, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_init(this, _configContext, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_set(this, _plugins, []);
+    _class_private_field_set(this, _configContext, createContext({}));
+    _class_private_field_set(this, _appContext, options.appContext);
+    _class_private_field_set(this, _configContext, createContext(options.serverConfig || {}));
+    _class_private_field_set(this, _options, options);
+  }
+}
+function createCoreManager() {
+  var _class_private_field_get_serverConfig;
+  const hooks = {
+    config: createAsyncWaterfall(),
+    prepare: createAsyncWaterfall(),
+    reset: createParallelWorkflow(),
+    prepareWebServer: createAsyncPipeline(),
+    fallback: createParallelWorkflow(),
+    prepareApiServer: createAsyncPipeline(),
+    afterMatch: createAsyncPipeline(),
+    afterRender: createAsyncPipeline(),
+    afterStreamingRender: createAsyncPipeline()
+  };
+  const pluginApi = {
+    useConfigContext: () => _class_private_field_get(this, _configContext).use().value,
+    useAppContext: () => _class_private_field_get(this, _appContext).use().value,
+    setAppContext: (c) => _class_private_field_get(this, _appContext).set(c)
+  };
+  const coreManager = createAsyncManager(hooks, pluginApi);
+  this.addPlugins(((_class_private_field_get_serverConfig = _class_private_field_get(this, _options).serverConfig) === null || _class_private_field_get_serverConfig === void 0 ? void 0 : _class_private_field_get_serverConfig.plugins) || []);
+  _class_private_field_get(this, _plugins).forEach((p) => {
+    const plugin = coreManager.createPlugin(p.setup, p);
+    coreManager.usePlugin(plugin);
+  });
+  return coreManager;
+}
+async function initConfigContext(runner) {
+  const { serverConfig, cliConfig } = _class_private_field_get(this, _options);
+  const mergedConfig = loadConfig({
+    cliConfig,
+    serverConfig: serverConfig || {}
+  });
+  const finalServerConfig = await runner.config(mergedConfig);
+  _class_private_field_get(this, _configContext).set(finalServerConfig);
+}
+export {
+  PluginManager
+};

package/dist/esm-node/{base/middlewares → plugins}/customServer/index.js

@@ -78,7 +78,7 @@ class CustomServer {
       return;
     }
     if (Array.isArray(serverMiddleware)) {
-      return getUnstableMiddlewares(serverMiddleware);
+      return getServerMidFromUnstableMid(serverMiddleware);
     }
     return async (c, next) => {
       var _c_env_node_res, _c_env_node, _c_env;
@@ -118,6 +118,14 @@ class CustomServer {
     });
   }
 }
+function getServerMidFromUnstableMid(serverMiddleware) {
+  return serverMiddleware.map((middleware) => {
+    return async (c, next) => {
+      const context = createMiddlewareContextFromHono(c);
+      return middleware(context, next);
+    };
+  });
+}
 function isRedirect(headers, code) {
   return [
     301,
@@ -126,14 +134,6 @@ function isRedirect(headers, code) {
     308
   ].includes(code || 0) || headers.get("Location");
 }
-function getUnstableMiddlewares(serverMiddleware) {
-  return serverMiddleware.map((middleware) => {
-    return async (c, next) => {
-      const context = createMiddlewareContextFromHono(c);
-      return middleware(context, next);
-    };
-  });
-}
 function createMiddlewareContextFromHono(c) {
   const loaderContext = getLoaderCtx(c);
   return {
@@ -161,5 +161,6 @@ function createMiddlewareContextFromHono(c) {
 }
 export {
   CustomServer,
-  getLoaderCtx2 as getLoaderCtx
+  getLoaderCtx2 as getLoaderCtx,
+  getServerMidFromUnstableMid
 };

package/dist/esm-node/plugins/favicon.js

@@ -0,0 +1,20 @@
+const faviconPlugin = () => ({
+  name: "@modern-js/plugin-favicon",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares } = api.useAppContext();
+        middlewares.push({
+          name: "favicon-fallback",
+          path: "/favicon.ico",
+          handler: async (c, _next) => {
+            return c.body(null, 204);
+          }
+        });
+      }
+    };
+  }
+});
+export {
+  faviconPlugin
+};

package/dist/esm-node/plugins/index.js

@@ -0,0 +1,15 @@
+import { renderPlugin, getRenderHandler } from "./render";
+import { faviconPlugin } from "./favicon";
+import { processedByPlugin } from "./processedBy";
+import { getLoaderCtx } from "./customServer";
+import { logPlugin } from "./log";
+import { monitorPlugin } from "./monitor";
+export {
+  faviconPlugin,
+  getLoaderCtx,
+  getRenderHandler,
+  logPlugin,
+  monitorPlugin,
+  processedByPlugin,
+  renderPlugin
+};

package/dist/esm-node/{base/middlewares/logger.js → plugins/log.js}

@@ -40,6 +40,10 @@ function logHandler() {
   return async function logger(c, next) {
     const { method } = c.req;
     const logger2 = c.get("logger");
+    if (!logger2) {
+      await next();
+      return;
+    }
     const path = getPathname(c.req.raw);
     const logFn = logger2.debug;
     log(logFn, "<--", method, path);
@@ -48,6 +52,20 @@ function logHandler() {
     log(logFn, "-->", method, path, c.res.status, time(start));
   };
 }
+const logPlugin = () => ({
+  name: "@modern-js/plugin-log",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares } = api.useAppContext();
+        middlewares.push({
+          name: "print_log",
+          handler: logHandler()
+        });
+      }
+    };
+  }
+});
 export {
-  logHandler
+  logPlugin
 };

package/dist/esm-node/plugins/monitor.js

@@ -0,0 +1,62 @@
+import { time } from "@modern-js/runtime-utils/time";
+import { ServerReportTimings } from "../constants";
+const defaultReporter = {
+  init() {
+  },
+  reportError() {
+  },
+  reportTiming() {
+  },
+  reportInfo() {
+  },
+  reportWarn() {
+  }
+};
+function initReporter(entryName) {
+  return async (c, next) => {
+    const reporter = c.get("reporter");
+    if (!reporter) {
+      await next();
+      return;
+    }
+    await reporter.init({
+      entryName
+    });
+    const getCost = time();
+    await next();
+    const cost = getCost();
+    reporter.reportTiming(ServerReportTimings.SERVER_HANDLE_REQUEST, cost);
+  };
+}
+const monitorPlugin = (options) => ({
+  name: "@modern-js/plugin-monitor",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares } = api.useAppContext();
+        middlewares.push({
+          name: "monitor",
+          handler: async (c, next) => {
+            const logger = c.get("logger");
+            if (!logger && options.logger) {
+              c.set("logger", options.logger);
+            }
+            const metrics = c.get("metrics");
+            if (!metrics && options.metrics) {
+              c.set("metrics", metrics);
+            }
+            const reporter = c.get("reporter");
+            if (!reporter) {
+              c.set("reporter", reporter || defaultReporter);
+            }
+            await next();
+          }
+        });
+      }
+    };
+  }
+});
+export {
+  initReporter,
+  monitorPlugin
+};

package/dist/esm-node/plugins/processedBy.js

@@ -0,0 +1,20 @@
+const processedByPlugin = () => ({
+  name: "@modern-js/plugin-processed",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares } = api.useAppContext();
+        middlewares.push({
+          name: "processed-by",
+          handler: async (c, next) => {
+            await next();
+            c.header("X-Processed-By", "Modern.js");
+          }
+        });
+      }
+    };
+  }
+});
+export {
+  processedByPlugin
+};