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

package/dist/esm/base/middlewares/renderHandler/ssrRender.js

@@ -0,0 +1,149 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { Readable } from "stream";
+import { LOADABLE_STATS_FILE, ROUTE_MANIFEST_FILE, SERVER_RENDER_FUNCTION_NAME } from "@modern-js/utils";
+import * as isbot from "isbot";
+import { createTransformStream, getPathModule } from "../../utils";
+import { REPLACE_REG } from "../../constants";
+import { parseHeaders, parseQuery, getHost } from "../../utils/request";
+import { createReadableStreamFromReadable } from "../../adapters/node/polyfills/stream";
+import { ServerTiming } from "./serverTiming";
+import { ssrCache } from "./ssrCache";
+const defaultReporter = {
+  init() {
+  },
+  reportError() {
+  },
+  reportTiming() {
+  },
+  reportInfo() {
+  },
+  reportWarn() {
+  }
+};
+async function ssrRender(request, { routeInfo, pwd, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq }) {
+  const { entryName } = routeInfo;
+  const path = await getPathModule();
+  const jsBundlePath = path.join(pwd, routeInfo.bundle);
+  const loadableUri = path.join(pwd, LOADABLE_STATS_FILE);
+  let loadableStats = {};
+  try {
+    loadableStats = await import(loadableUri);
+  } catch (_) {
+  }
+  const routesManifestUri = path.join(pwd, ROUTE_MANIFEST_FILE);
+  let routeManifest;
+  try {
+    routeManifest = await import(routesManifestUri);
+  } catch (_) {
+  }
+  const host = getHost(request);
+  const isSpider = isbot.default(request.headers.get("user-agent"));
+  const responseProxy = new ResponseProxy();
+  const query = parseQuery(request);
+  const headers = parseHeaders(request);
+  const ssrContext = {
+    request: {
+      baseUrl: routeInfo.urlPath,
+      params: {},
+      // eslint-disable-next-line node/no-unsupported-features/node-builtins, node/prefer-global/url
+      pathname: new URL(request.url).pathname,
+      host,
+      query,
+      url: request.url,
+      headers
+    },
+    response: {
+      setHeader(key, value) {
+        responseProxy.headers.set(key, value);
+      },
+      status(code) {
+        responseProxy.status = code;
+      }
+    },
+    redirection: {},
+    template: html,
+    loadableStats,
+    routeManifest,
+    entryName,
+    staticGenerate,
+    logger,
+    serverTiming: new ServerTiming(responseProxy.headers, metaName),
+    reporter: reporter || defaultReporter,
+    /** @deprecated node req */
+    req: void 0,
+    /** @deprecated node res  */
+    res: void 0,
+    isSpider,
+    nonce
+  };
+  const jsBundle = await import(jsBundlePath);
+  const incomingMessage = nodeReq ? nodeReq : new IncomingMessgeProxy(request);
+  const cacheControl = await ssrCache.matchCacheControl(incomingMessage);
+  let ssrResult;
+  const render = jsBundle[SERVER_RENDER_FUNCTION_NAME];
+  if (cacheControl) {
+    ssrResult = await ssrCache.getCache(request, cacheControl, render, ssrContext);
+  } else {
+    ssrResult = await render(ssrContext);
+  }
+  const { redirection } = ssrContext;
+  if (redirection.url) {
+    const { headers: headers2 } = responseProxy;
+    headers2.set("Location", redirection.url);
+    return new Response(null, {
+      status: redirection.status || 302,
+      headers: {
+        Location: redirection.url
+      }
+    });
+  }
+  const serverData = {
+    router: {
+      baseUrl: routeInfo.urlPath,
+      // TODO: parse
+      params: {}
+    }
+  };
+  const data = ssrResult instanceof Readable ? createReadableStreamFromReadable(ssrResult) : ssrResult;
+  const body = injectServerData(data, serverData);
+  return new Response(body, {
+    status: responseProxy.status,
+    headers: responseProxy.headers
+  });
+}
+function injectServerData(data, serverData) {
+  const { head } = REPLACE_REG.before;
+  const searchValue = new RegExp(head);
+  const replcaeCb = (beforeHead) => `${beforeHead}<script type="application/json" id="__MODERN_SERVER_DATA__">${JSON.stringify(serverData)}</script>`;
+  if (typeof data === "string") {
+    return data.replace(searchValue, replcaeCb);
+  } else {
+    const stream = createTransformStream((before) => {
+      return before.replace(searchValue, replcaeCb);
+    });
+    data.pipeThrough(stream);
+    return stream.readable;
+  }
+}
+class ResponseProxy {
+  constructor() {
+    _define_property(this, "headers", new Headers());
+    _define_property(this, "status", 200);
+    this.headers.set("content-type", "text/html; charset=UTF-8");
+  }
+}
+class IncomingMessgeProxy {
+  constructor(req) {
+    _define_property(this, "headers", {});
+    _define_property(this, "method", void 0);
+    _define_property(this, "url", void 0);
+    req.headers.forEach((value, key) => {
+      this.headers[key] = value;
+    });
+    this.method = req.method;
+    this.url = new URL(req.url).pathname;
+  }
+}
+export {
+  ssrRender
+};

package/dist/esm/base/serverBase.js

@@ -0,0 +1,143 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { INTERNAL_SERVER_PLUGINS, OUTPUT_CONFIG_FILE, SHARED_DIR, ensureAbsolutePath } from "@modern-js/utils";
+import { Hono } from "hono";
+import { AppContext, ConfigContext, loadPlugins, serverManager } from "../core";
+import { debug, getPathModule, getServerConfigPath, loadConfig, requireConfig } from "./utils";
+class ServerBase {
+  /**
+  * 初始化顺序
+  * - 获取 server runtime config
+  * - 设置 context
+  * - 创建 hooksRunner
+  * - 合并插件，内置插件和 serverConfig 中配置的插件
+  * - 执行 config hook
+  * - 获取最终的配置
+  * - 设置配置到 context
+  * - 执行 prepare hook
+  */
+  async init() {
+    const { options } = this;
+    await this.initServerConfig(options);
+    await this.injectContext(options);
+    this.runner = await this.createHookRunner();
+    await this.initConfig(this.runner, options);
+    await this.injectContext(options);
+    await this.runner.prepare();
+    return this;
+  }
+  async createHookRunner() {
+    serverManager.clear();
+    const { options } = this;
+    const { internalPlugins = INTERNAL_SERVER_PLUGINS, pwd, plugins = [] } = options;
+    const serverPlugins = this.serverConfig.plugins || [];
+    const loadedPlugins = loadPlugins(options.appContext.appDirectory || pwd, [
+      ...serverPlugins,
+      ...plugins
+    ], {
+      internalPlugins
+    });
+    debug("plugins", loadedPlugins);
+    loadedPlugins.forEach((p) => {
+      serverManager.usePlugin(p);
+    });
+    const hooksRunner = await serverManager.init();
+    return hooksRunner;
+  }
+  async initServerConfig(options) {
+    const { pwd, serverConfigFile } = options;
+    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 path = await getPathModule();
+    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 === null || appContext === void 0 ? void 0 : appContext.sharedDirectory) || path.resolve(appContext.appDirectory || "", SHARED_DIR),
+      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 getPathModule();
+    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;
+  }
+  get use() {
+    return this.app.use;
+  }
+  get get() {
+    return this.app.get;
+  }
+  get post() {
+    return this.app.post;
+  }
+  get put() {
+    return this.app.put;
+  }
+  get delete() {
+    return this.app.delete;
+  }
+  get patch() {
+    return this.app.patch;
+  }
+  get handle() {
+    return this.app.fetch;
+  }
+  get request() {
+    return this.app.request;
+  }
+  get notFound() {
+    return this.app.notFound;
+  }
+  get onError() {
+    return this.app.onError;
+  }
+  constructor(options) {
+    _define_property(this, "options", void 0);
+    _define_property(this, "runner", void 0);
+    _define_property(this, "app", void 0);
+    _define_property(this, "serverConfig", {});
+    this.options = options;
+    this.app = new Hono();
+  }
+}
+export {
+  ServerBase
+};

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

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

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

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

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

@@ -0,0 +1,20 @@
+const getRuntimeEnv = () => {
+  var _global_process_release, _global_process, _global;
+  if (((_global = global) === null || _global === void 0 ? void 0 : (_global_process = _global.process) === null || _global_process === void 0 ? void 0 : (_global_process_release = _global_process.release) === null || _global_process_release === void 0 ? void 0 : _global_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/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/base/utils/index.js

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

package/dist/esm/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/base/utils/path.js

@@ -0,0 +1,12 @@
+async function getPathModule() {
+  let path;
+  try {
+    path = await import("path");
+  } catch (_) {
+    path = await import("path-browserify");
+  }
+  return path;
+}
+export {
+  getPathModule
+};

package/dist/esm/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/base/utils/serverConfig.js

@@ -0,0 +1,35 @@
+import { compatRequire, fs, DEFAULT_SERVER_CONFIG } from "@modern-js/utils";
+import mergeDeep from "merge-deep";
+import { getPathModule } from "./path";
+const getServerConfigPath = async (distDirectory, serverConfigFile = DEFAULT_SERVER_CONFIG) => {
+  const path = await getPathModule();
+  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/base/utils/transformStream.js

@@ -0,0 +1,14 @@
+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));
+    }
+  });
+}
+export {
+  createTransformStream
+};

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

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

package/dist/esm/core/index.js

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

package/dist/esm/{loadPlugins.js → 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) {

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

@@ -5,10 +5,9 @@ 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();
@@ -52,7 +51,6 @@ const serverHooks = {
   repack,
   onApiChange,
   beforeServerInit,
-  afterServerInit,
   setupCompiler,
   beforeRouteSet,
   afterRouteSet,

package/dist/esm/core/server.js

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

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/types/base/adapters/node/bff.d.ts

@@ -0,0 +1,4 @@
+import type { ServerBaseOptions } from '../../../core/server';
+import { BindRenderHandleOptions } from '../../../base/middlewares';
+import { ServerBase } 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,30 @@
+import { Metrics, Reporter } from '@modern-js/types/server';
+import { Logger } from '@modern-js/types';
+import { NodeRequest, NodeResponse } from '../../../core/plugin';
+import { HonoContext, HonoRequest, Middleware, Next } from '../../../core/server';
+type NodeBindings = {
+    node: {
+        req: NodeRequest & {
+            __honoRequest: HonoRequest;
+            __templates: Record<string, string>;
+        };
+        res: NodeResponse;
+    };
+};
+type NodeVariables = {
+    reporter: Reporter;
+    logger: Logger;
+    templates?: Record<string, string>;
+    metrics?: Metrics;
+};
+export type HonoNodeEnv = {
+    Bindings: NodeBindings;
+    Variables: NodeVariables;
+};
+export type ServerNodeMiddleware = Middleware<HonoNodeEnv>;
+export type ServerNodeContext = HonoContext<HonoNodeEnv>;
+type Handler = (req: NodeRequest, res: NodeResponse) => void | Promise<void>;
+export declare const httpCallBack2HonoMid: (handler: Handler) => (context: HonoContext<HonoNodeEnv>, 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 * from './loadServer';
+export * from './hono';
+export * from './node';
+export * from './bff';
+export * from './middlewares';
+export * from './polyfills';

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

@@ -0,0 +1,3 @@
+import { ServerBaseOptions } from '../../../core/server';
+/** 读取 .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,3 @@
+export * from './mock';
+export * from './serverStatic';
+export * from './templates';

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/serverStatic.d.ts

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

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

@@ -0,0 +1,3 @@
+import { ServerRoute } from '@modern-js/types';
+import { ServerNodeMiddleware } from '../hono';
+export declare function createInjectHtml(pwd: string, routes?: ServerRoute[]): ServerNodeMiddleware;

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

@@ -0,0 +1,12 @@
+/// <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 & {
+    getRequestHandler: () => ReturnType<typeof getRequestListener>;
+};
+export declare const createNodeServer: (handleRequest: 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;