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

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

@@ -0,0 +1,168 @@
+import { INTERNAL_SERVER_PLUGINS } from "@modern-js/utils/universal/constants";
+import { Hono } from "hono";
+import { AppContext, ConfigContext, serverManager, createPlugin } from "../core";
+import { getRuntimeEnv } from "./utils";
+class ServerBase {
+  /**
+  * 初始化顺序
+  * - 获取 server runtime config
+  * - 设置 context
+  * - 创建 hooksRunner
+  * - 合并插件，内置插件和 serverConfig 中配置的插件
+  * - 执行 config hook
+  * - 获取最终的配置
+  * - 设置配置到 context
+  * - 执行 prepare hook
+  */
+  async init() {
+    const { options } = this;
+    const runtimeEnv = getRuntimeEnv();
+    runtimeEnv === "node" && await this.initServerConfig(options);
+    await this.injectContext(options);
+    this.runner = await this.createHookRunner();
+    runtimeEnv === "node" && await this.initConfig(this.runner, options);
+    await this.injectContext(options);
+    await this.runner.prepare();
+    return this;
+  }
+  async createHookRunner() {
+    serverManager.clear();
+    const runtimeEnv = getRuntimeEnv();
+    const internalPlugins = runtimeEnv === "node" ? await this.loadInternalPlugins() : [];
+    const externalPlugins = this.loadExternalPlugins();
+    const loadedPlugins = [
+      ...internalPlugins,
+      ...externalPlugins
+    ];
+    loadedPlugins.forEach((p) => {
+      serverManager.usePlugin(p);
+    });
+    const hooksRunner = await serverManager.init();
+    return hooksRunner;
+  }
+  async loadInternalPlugins() {
+    const { internalPlugins: plugins = INTERNAL_SERVER_PLUGINS, appContext, pwd } = this.options;
+    const loadPluginsModule = "../core/loadPlugins";
+    const { loadPlugins } = await import(loadPluginsModule);
+    const internalPlugins = loadPlugins(appContext.appDirectory || pwd, plugins);
+    return internalPlugins;
+  }
+  loadExternalPlugins() {
+    const { plugins = [] } = this.options;
+    const configPlugins = this.serverConfig.plugins || [];
+    const externalPlugins = [
+      ...plugins,
+      ...configPlugins
+    ];
+    return externalPlugins.map((plugin) => createPlugin(plugin.setup, plugin));
+  }
+  async initServerConfig(options) {
+    const { pwd, serverConfigFile } = options;
+    const utilsModuleName = "./utils/serverConfig";
+    const { getServerConfigPath, requireConfig } = await import(utilsModuleName);
+    const serverConfigPath = await getServerConfigPath(pwd, serverConfigFile);
+    const serverConfig = requireConfig(serverConfigPath);
+    this.serverConfig = serverConfig;
+  }
+  async injectContext(options) {
+    const appContext = await this.initAppContext();
+    const { config, pwd } = options;
+    ConfigContext.set(config);
+    AppContext.set({
+      ...appContext,
+      serverBase: this,
+      distDirectory: pwd
+    });
+  }
+  async initAppContext() {
+    const { options } = this;
+    const { pwd, plugins = [], appContext } = options;
+    const serverPlugins = plugins.map((p) => ({
+      server: p
+    }));
+    return {
+      appDirectory: (appContext === null || appContext === void 0 ? void 0 : appContext.appDirectory) || "",
+      apiDirectory: appContext === null || appContext === void 0 ? void 0 : appContext.apiDirectory,
+      lambdaDirectory: appContext === null || appContext === void 0 ? void 0 : appContext.lambdaDirectory,
+      sharedDirectory: appContext.sharedDirectory || "",
+      distDirectory: pwd,
+      plugins: serverPlugins
+    };
+  }
+  /**
+  * Execute config hooks
+  * @param runner
+  * @param options
+  */
+  runConfigHook(runner, serverConfig) {
+    const newServerConfig = runner.config(serverConfig || {});
+    return newServerConfig;
+  }
+  async initConfig(runner, options) {
+    const path = await import("path").catch((_) => {
+      return {};
+    });
+    const utilsModuleName = "@modern-js/utils";
+    const { ensureAbsolutePath, OUTPUT_CONFIG_FILE } = await import(utilsModuleName);
+    const configModuleName = "./utils/serverConfig";
+    const { loadConfig } = await import(configModuleName);
+    const { pwd, config } = options;
+    const { serverConfig } = this;
+    const finalServerConfig = this.runConfigHook(runner, serverConfig);
+    const resolvedConfigPath = ensureAbsolutePath(pwd, path.join(config.output.path || "dist", OUTPUT_CONFIG_FILE));
+    options.config = loadConfig({
+      cliConfig: config,
+      serverConfig: finalServerConfig,
+      resolvedConfigPath
+    });
+  }
+  get all() {
+    return this.app.all.bind(this.app);
+  }
+  get use() {
+    return this.app.use.bind(this.app);
+  }
+  get get() {
+    return this.app.get.bind(this.app);
+  }
+  get post() {
+    return this.app.post.bind(this.app);
+  }
+  get put() {
+    return this.app.put.bind(this.app);
+  }
+  get delete() {
+    return this.app.delete.bind(this.app);
+  }
+  get patch() {
+    return this.app.patch.bind(this.app);
+  }
+  get handle() {
+    return this.app.fetch.bind(this.app);
+  }
+  get request() {
+    return this.app.request.bind(this.app);
+  }
+  get notFound() {
+    return this.app.notFound.bind(this.app);
+  }
+  get onError() {
+    return this.app.onError.bind(this.app);
+  }
+  constructor(options) {
+    this.serverConfig = {};
+    this.options = options;
+    this.app = new Hono();
+  }
+}
+function createServerBase(options) {
+  if (options == null) {
+    throw new Error("can not start server without options");
+  }
+  const server = new ServerBase(options);
+  return server;
+}
+export {
+  ServerBase,
+  createServerBase
+};

package/dist/esm-node/base/utils/debug.js

@@ -0,0 +1,5 @@
+import { createDebugger } from "@modern-js/utils";
+const debug = createDebugger("prod-server");
+export {
+  debug
+};

package/dist/esm-node/base/utils/entry.js

@@ -0,0 +1,6 @@
+const sortRoutes = (route1, route2) => {
+  return route2.urlPath.length - route1.urlPath.length;
+};
+export {
+  sortRoutes
+};

package/dist/esm-node/base/utils/env.js

@@ -0,0 +1,20 @@
+const getRuntimeEnv = () => {
+  var _globalThis_process_release, _globalThis_process, _globalThis;
+  if (((_globalThis = globalThis) === null || _globalThis === void 0 ? void 0 : (_globalThis_process = _globalThis.process) === null || _globalThis_process === void 0 ? void 0 : (_globalThis_process_release = _globalThis_process.release) === null || _globalThis_process_release === void 0 ? void 0 : _globalThis_process_release.name) === "node") {
+    return "node";
+  }
+  return "other";
+};
+const checkIsProd = () => {
+  const env = getRuntimeEnv();
+  switch (env) {
+    case "node":
+      return process.env.NODE_ENV === "production";
+    default:
+      return false;
+  }
+};
+export {
+  checkIsProd,
+  getRuntimeEnv
+};

package/dist/esm-node/base/utils/error.js

@@ -0,0 +1,41 @@
+const ERROR_PAGE_TEXT = {
+  404: "This page could not be found.",
+  500: "Internal Server Error."
+};
+const createErrorHtml = (status) => {
+  const text = ERROR_PAGE_TEXT[status] || "";
+  const title = `${status}: ${text}`;
+  return `<!DOCTYPE html>
+  <html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width">
+    <title>${title}</title>
+    <style>
+      html,body {
+        margin: 0;
+      }
+
+      .page-container {
+        color: #000;
+        background: #fff;
+        height: 100vh;
+        text-align: center;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="page-container">
+    <h1>${status}</h1>
+    <div>${text}</div>
+  </body>
+  </html>
+  `;
+};
+export {
+  createErrorHtml
+};

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

@@ -0,0 +1,7 @@
+export * from "./env";
+export * from "./request";
+export * from "./transformStream";
+export * from "./middlewareCollector";
+export * from "./error";
+export * from "./warmup";
+export * from "./entry";

package/dist/esm-node/base/utils/middlewareCollector.js

@@ -0,0 +1,29 @@
+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
+  };
+};
+export {
+  createMiddlewareCollecter,
+  mergeExtension
+};

package/dist/esm-node/base/utils/request.js

@@ -0,0 +1,38 @@
+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;
+}
+export {
+  getHost,
+  getPathname,
+  parseHeaders,
+  parseQuery
+};

package/dist/esm-node/base/utils/serverConfig.js

@@ -0,0 +1,34 @@
+import { compatRequire, fs, DEFAULT_SERVER_CONFIG } from "@modern-js/utils";
+import mergeDeep from "merge-deep";
+const getServerConfigPath = async (distDirectory, serverConfigFile = DEFAULT_SERVER_CONFIG) => {
+  const path = await import("path");
+  const serverConfigPath = path.join(distDirectory, serverConfigFile);
+  return `${serverConfigPath}.js`;
+};
+const requireConfig = (serverConfigPath) => {
+  if (fs.pathExistsSync(serverConfigPath)) {
+    return compatRequire(serverConfigPath);
+  }
+  return {};
+};
+const loadConfig = ({ cliConfig, serverConfig, resolvedConfigPath }) => {
+  let config = null;
+  if (process.env.NODE_ENV === "production") {
+    const resolvedConfig = requireConfig(resolvedConfigPath);
+    config = mergeDeep({
+      ...resolvedConfig,
+      plugins: []
+    }, serverConfig, cliConfig);
+  } else {
+    config = mergeDeep({
+      ...cliConfig,
+      plugins: []
+    }, serverConfig);
+  }
+  return config;
+};
+export {
+  getServerConfigPath,
+  loadConfig,
+  requireConfig
+};

package/dist/esm-node/base/utils/transformStream.js

@@ -0,0 +1,36 @@
+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));
+    }
+  });
+}
+function transformResponse(response, transformCb) {
+  let readable = null;
+  if (response.body) {
+    const stream = createTransformStream(async (before) => {
+      if (Array.isArray(transformCb)) {
+        return transformCb.reduce(async (before2, cb) => {
+          return cb(await before2);
+        }, Promise.resolve(before));
+      } else {
+        return transformCb(before);
+      }
+    });
+    response.body.pipeThrough(stream);
+    readable = stream.readable;
+  }
+  return new Response(readable, {
+    status: response.status,
+    headers: response.headers,
+    statusText: response.statusText
+  });
+}
+export {
+  createTransformStream,
+  transformResponse
+};

package/dist/esm-node/base/utils/warmup.js

@@ -0,0 +1,9 @@
+function warmup(bundles) {
+  bundles.forEach((bundle) => {
+    bundle && import(bundle).catch((_) => {
+    });
+  });
+}
+export {
+  warmup
+};

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

@@ -0,0 +1 @@
+export * from "./plugin";

package/dist/{esm → esm-node/core}/loadPlugins.js

@@ -1,5 +1,5 @@
 import { compatRequire, getInternalPlugins, tryResolve } from "@modern-js/utils";
-import { createPlugin } from "./plugin";
+import { createPlugin } from "../core/plugin";
 const resolvePlugin = (p, appDirectory) => {
   const isPluginInstance = typeof p !== "string";
   if (isPluginInstance) {
@@ -14,12 +14,9 @@ const resolvePlugin = (p, appDirectory) => {
     module: createPlugin(pluginInstance.setup, pluginInstance)
   };
 };
-const loadPlugins = (appDirectory, configPlugins, options) => {
-  const loadedPlugins = getInternalPlugins(appDirectory, options.internalPlugins);
-  return [
-    ...loadedPlugins,
-    ...configPlugins
-  ].map((plugin) => {
+const loadPlugins = (appDirectory, internalPlugins) => {
+  const loadedPlugins = getInternalPlugins(appDirectory, internalPlugins);
+  return loadedPlugins.map((plugin) => {
     const { module } = resolvePlugin(plugin, appDirectory);
     return module;
   });

package/dist/{esm → esm-node/core}/plugin.js

@@ -2,34 +2,14 @@ import { createContext, createAsyncManager, createAsyncPipeline, createAsyncWate
 const gather = createParallelWorkflow();
 const config = createWaterfall();
 const prepare = createWaterfall();
-const prepareLoaderHandler = createAsyncPipeline();
 const prepareWebServer = createAsyncPipeline();
 const prepareApiServer = createAsyncPipeline();
-const onApiChange = createWaterfall();
+const onApiChange = createAsyncWaterfall();
 const repack = createWaterfall();
 const beforeServerInit = createAsyncWaterfall();
-const afterServerInit = createAsyncWaterfall();
-const setupCompiler = createParallelWorkflow();
-const beforeRouteSet = createAsyncPipeline();
-const afterRouteSet = createAsyncPipeline();
-const beforeProdServer = createParallelWorkflow();
-const afterProdServer = createParallelWorkflow();
-const listen = createParallelWorkflow();
-const beforeServerReset = createParallelWorkflow();
-const afterServerReset = createParallelWorkflow();
-const extendSSRContext = createAsyncWaterfall();
-const extendContext = createAsyncPipeline();
-const handleError = createParallelWorkflow();
-const handleSSRFallback = createParallelWorkflow();
-const beforeMatch = createAsyncPipeline();
 const afterMatch = createAsyncPipeline();
-const prefetch = createParallelWorkflow();
-const renderToString = createAsyncPipeline();
-const beforeRender = createAsyncPipeline();
 const afterRender = createAsyncPipeline();
 const afterStreamingRender = createAsyncPipeline();
-const beforeSend = createAsyncPipeline();
-const afterSend = createParallelWorkflow();
 const reset = createParallelWorkflow();
 const AppContext = createContext({});
 const setAppContext = (value) => AppContext.set(value);
@@ -46,35 +26,14 @@ const serverHooks = {
   gather,
   config,
   prepare,
-  prepareLoaderHandler,
   prepareWebServer,
   prepareApiServer,
   repack,
   onApiChange,
   beforeServerInit,
-  afterServerInit,
-  setupCompiler,
-  beforeRouteSet,
-  afterRouteSet,
-  beforeProdServer,
-  afterProdServer,
-  listen,
-  beforeServerReset,
-  afterServerReset,
-  // request hook
-  extendSSRContext,
-  extendContext,
-  handleError,
-  handleSSRFallback,
-  beforeMatch,
   afterMatch,
-  prefetch,
-  renderToString,
-  beforeRender,
   afterRender,
   afterStreamingRender,
-  beforeSend,
-  afterSend,
   reset
 };
 const createServerManager = () => createAsyncManager(serverHooks, pluginAPI);

package/dist/esm-node/index.js

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

package/dist/esm-node/types/config/index.js

@@ -0,0 +1,6 @@
+export * from "./bff";
+export * from "./html";
+export * from "./output";
+export * from "./server";
+export * from "./source";
+export * from "./tools";

package/dist/types/base/adapters/node/bff.d.ts

@@ -0,0 +1,3 @@
+import { BindRenderHandleOptions } from '../../../base/middlewares';
+import { ServerBase, type ServerBaseOptions } from '../../serverBase';
+export declare const bindBFFHandler: (server: ServerBase, options: ServerBaseOptions & BindRenderHandleOptions) => Promise<void>;

package/dist/types/base/adapters/node/hono.d.ts

@@ -0,0 +1,22 @@
+import { NodeRequest, NodeResponse } from '../../../core/plugin';
+import { Context, HonoRequest, ServerEnv, Middleware, Next, ServerManifest } from '../../../core/server';
+type NodeBindings = {
+    node: {
+        req: NodeRequest & {
+            __honoRequest: HonoRequest;
+            __templates: Record<string, string>;
+            __serverManifest: ServerManifest;
+        };
+        res: NodeResponse;
+    };
+};
+export type ServerNodeEnv = {
+    Bindings: NodeBindings;
+};
+export type ServerNodeMiddleware = Middleware<ServerNodeEnv>;
+export type ServerNodeContext = Context<ServerNodeEnv>;
+type Handler = (req: NodeRequest, res: NodeResponse) => void | Promise<void>;
+export declare const httpCallBack2HonoMid: (handler: Handler) => (context: Context<ServerNodeEnv & ServerEnv>, next: Next) => Promise<void>;
+type ConnectMiddleware = ((req: NodeRequest, res: NodeResponse, callback: (...args: unknown[]) => void) => void) | ((req: NodeRequest, res: NodeResponse) => void);
+export declare const connectMid2HonoMid: (handler: ConnectMiddleware) => Middleware;
+export {};

package/dist/types/base/adapters/node/index.d.ts

@@ -0,0 +1,6 @@
+export { loadServerEnv } from './loadServer';
+export { httpCallBack2HonoMid, connectMid2HonoMid } from './hono';
+export type { ServerNodeContext, ServerNodeMiddleware } from './hono';
+export { createNodeServer, sendResponse, createWebRequest } from './node';
+export { bindBFFHandler } from './bff';
+export { createStaticMiddleware, registerMockHandlers, injectServerManifest, injectTemplates, getHtmlTemplates, getServerManifest, } from './middlewares';

package/dist/types/base/adapters/node/loadServer.d.ts

@@ -0,0 +1,3 @@
+import type { ServerBaseOptions } from '../../serverBase';
+/** 读取 .env.{process.env.MODERN_ENV} 文件，加载环境变量 */
+export declare function loadServerEnv(options: ServerBaseOptions): Promise<void>;

package/dist/types/base/adapters/node/middlewares/index.d.ts

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

package/dist/types/base/adapters/node/middlewares/mock.d.ts

@@ -0,0 +1,5 @@
+import type { ServerBase } from '../../../serverBase';
+export declare const registerMockHandlers: ({ pwd, server, }: {
+    pwd: string;
+    server: ServerBase;
+}) => Promise<null | undefined>;

package/dist/types/base/adapters/node/middlewares/serverManifest.d.ts

@@ -0,0 +1,4 @@
+import type { ServerRoute } from '@modern-js/types';
+import { Middleware, ServerEnv, ServerManifest } from '../../../../core/server';
+export declare function getServerManifest(pwd: string, routes: ServerRoute[]): Promise<ServerManifest>;
+export declare function injectServerManifest(pwd: string, routes?: ServerRoute[]): Middleware<ServerEnv>;

package/dist/types/base/adapters/node/middlewares/serverPublic.d.ts

@@ -0,0 +1,7 @@
+import { ServerRoute } from '@modern-js/types';
+import { Middleware } from '../../../../core/server';
+export type PublicMiddlwareOptions = {
+    pwd: string;
+    routes: ServerRoute[];
+};
+export declare function createPublicMiddleware({ pwd, routes, }: PublicMiddlwareOptions): Middleware;

package/dist/types/base/adapters/node/middlewares/serverStatic.d.ts

@@ -0,0 +1,11 @@
+import { ServerRoute } from '@modern-js/types';
+import type { OutputNormalizedConfig, HtmlNormalizedConfig } from '../../../../types/config';
+import { Middleware } from '../../../../core/server';
+interface ServerStaticOptions {
+    pwd: string;
+    output: OutputNormalizedConfig;
+    html: HtmlNormalizedConfig;
+    routes?: ServerRoute[];
+}
+export declare function createStaticMiddleware(options: ServerStaticOptions): Middleware;
+export {};

package/dist/types/base/adapters/node/middlewares/templates.d.ts

@@ -0,0 +1,4 @@
+import { ServerRoute } from '@modern-js/types';
+import { Middleware, ServerEnv } from '../../../../core/server';
+export declare function getHtmlTemplates(pwd: string, routes: ServerRoute[]): Promise<Record<string, string>>;
+export declare function injectTemplates(pwd: string, routes?: ServerRoute[]): Middleware<ServerEnv>;

package/dist/types/base/adapters/node/node.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Server as NodeServer } from 'node:http';
+import { NodeRequest, NodeResponse } from '../../../core/plugin';
+import { RequestHandler } from '../../../core/server';
+export declare const createWebRequest: (req: NodeRequest, res: NodeResponse) => Request;
+export declare const sendResponse: (response: Response, res: NodeResponse) => Promise<void>;
+declare const getRequestListener: (handler: RequestHandler) => (req: NodeRequest, res: NodeResponse) => Promise<void>;
+type NodeServerWrapper = NodeServer & {
+    getRequestListener: () => ReturnType<typeof getRequestListener>;
+    getRequestHandler: () => RequestHandler;
+};
+export declare const createNodeServer: (requestHandler: RequestHandler) => NodeServerWrapper;
+export {};

package/dist/types/base/adapters/node/polyfills/index.d.ts

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

package/dist/types/base/adapters/node/polyfills/install.d.ts

@@ -0,0 +1 @@
+export declare const installGlobals: () => void;