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

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * The following code is modified based on
+ * https://github.com/remix-run/remix/blob/f7defe0b46c50947f6269d5ab5b6e3fe59339054/packages/remix-node/stream.ts#L3
+ *
+ * MIT Licensed
+ * Author Michael Jackson
+ * Copyright 2021 Remix Software Inc.
+ * https://github.com/remix-run/remix/blob/f7defe0b46c50947f6269d5ab5b6e3fe59339054/LICENSE.md
+ */
+import type { Readable, Writable } from 'node:stream';
+export declare function writeReadableStreamToWritable(stream: ReadableStream, writable: Writable): Promise<void>;
+export declare function writeAsyncIterableToWritable(iterable: AsyncIterable<Uint8Array>, writable: Writable): Promise<void>;
+export declare function readableStreamToString(stream: ReadableStream<Uint8Array>, encoding?: BufferEncoding): Promise<string>;
+export declare const createReadableStreamFromReadable: (source: Readable & {
+    readableHighWaterMark?: number;
+}) => ReadableStream<Uint8Array>;

package/dist/types/base/constants.d.ts

@@ -0,0 +1,23 @@
+export declare const AGGRED_DIR: {
+    mock: string;
+    server: string;
+    api: string;
+    shared: string;
+    lambda: string;
+};
+export declare const REPLACE_REG: {
+    before: {
+        head: string;
+        body: string;
+    };
+    after: {
+        head: string;
+        body: string;
+    };
+};
+export declare enum ServerReportTimings {
+    SERVER_HANDLE_REQUEST = "server-handle-request",
+    SERVER_MIDDLEWARE = "server-middleware",
+    SERVER_HOOK_AFTER_RENDER = "server-hook-after-render",
+    SERVER_HOOK_AFTER_MATCH = "server-hook-after-match"
+}

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

@@ -0,0 +1,9 @@
+import type { ServerBaseOptions, Next, Middleware, HonoEnv } from '../core/server';
+import { ServerBase } from './serverBase';
+export { createErrorHtml } from './utils';
+export { AGGRED_DIR } from './constants';
+export { httpCallBack2HonoMid, createNodeServer, loadServerEnv, connectMid2HonoMid, sendResponse, createStaticMiddleware, bindBFFHandler, registerMockHandlers, createInjectHtml, } from './adapters/node';
+export { favionFallbackMiddleware, bindDataHandlers, injectReporter, getRenderHandler, injectLogger, bindRenderHandler, } from './middlewares';
+export type { BindRenderHandleOptions } from './middlewares';
+export declare function createServerBase<E extends HonoEnv>(options: ServerBaseOptions): ServerBase<E>;
+export type { ServerBaseOptions, Next, Middleware, ServerBase };

package/dist/types/base/middlewares/customServer/base.d.ts

@@ -0,0 +1,3 @@
+import { HookContext, Metrics } from '@modern-js/types';
+import { HonoContext, Logger } from '../../../core/server';
+export declare function createBaseHookContext(c: HonoContext, logger: Logger, metrics?: Metrics): HookContext;

package/dist/types/base/middlewares/customServer/context.d.ts

@@ -0,0 +1,7 @@
+import { AfterMatchContext, AfterRenderContext, Metrics, MiddlewareContext, Logger, AfterStreamingRenderContext, ServerRoute } from '@modern-js/types';
+import { HonoContext } from '../../../core/server';
+import type { HonoNodeEnv } from '../../adapters/node';
+export declare function createAfterMatchCtx(c: HonoContext, entryName: string, logger: Logger, metrics?: Metrics): AfterMatchContext;
+export declare function createAfterRenderCtx(c: HonoContext, logger: Logger, metrics?: Metrics): Promise<AfterRenderContext>;
+export declare function createCustomMiddlewaresCtx(c: HonoContext<HonoNodeEnv>, logger: Logger, metrics?: Metrics): MiddlewareContext;
+export declare function createAfterStreamingRenderContext(c: HonoContext, logger: Logger, route: Partial<ServerRoute>, metrics?: Metrics): (chunk: string) => AfterStreamingRenderContext;

package/dist/types/base/middlewares/customServer/index.d.ts

@@ -0,0 +1,13 @@
+import { ServerRoute } from '@modern-js/types';
+import { ServerBase } from '../../serverBase';
+import { ServerHookRunner } from '../../../core/plugin';
+import { Middleware } from '../../../core/server';
+import { HonoNodeEnv } from '../../adapters/node';
+export declare class CustomServer {
+    private runner;
+    private serverMiddlewarePromise;
+    private serverBase;
+    constructor(runner: ServerHookRunner, serverBase: ServerBase, pwd: string);
+    getHookMiddleware(entryName: string, routes: ServerRoute[]): Middleware<HonoNodeEnv>;
+    getServerMiddleware(): Middleware<HonoNodeEnv>;
+}

package/dist/types/base/middlewares/customServer/routerApi.d.ts

@@ -0,0 +1,9 @@
+export declare class RouterAPI {
+    current: string;
+    status: number;
+    url: string;
+    constructor(entryName: string);
+    redirect(url: string, status?: number): void;
+    rewrite(entryName: string): void;
+    use(entryName: string): void;
+}

package/dist/types/base/middlewares/customServer/template.d.ts

@@ -0,0 +1,11 @@
+export declare class TemplateApi {
+    private body;
+    constructor(body: string);
+    set(content: string): void;
+    get(): string;
+    prependHead(fragment: string): void;
+    appendHead(fragment: string): void;
+    prependBody(fragment: string): void;
+    appendBody(fragment: string): void;
+    private replaceBody;
+}

package/dist/types/base/middlewares/dataHandler.d.ts

@@ -0,0 +1,3 @@
+import type { ServerRoute } from '@modern-js/types';
+import type { ServerBase } from '../serverBase';
+export declare const bindDataHandlers: (server: ServerBase, routes: ServerRoute[], distDir: string) => Promise<void>;

package/dist/types/base/middlewares/faviconFallback.d.ts

@@ -0,0 +1,2 @@
+import { Middleware } from '../../core/server';
+export declare const favionFallbackMiddleware: Middleware;

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

@@ -0,0 +1,4 @@
+export * from './faviconFallback';
+export * from './dataHandler';
+export * from './monitor';
+export * from './renderHandler';

package/dist/types/base/middlewares/monitor.d.ts

@@ -0,0 +1,7 @@
+import type { Next } from 'hono';
+import { Logger } from '@modern-js/types';
+import { HonoContext } from '../../core/server';
+import { HonoNodeEnv } from '../adapters/node';
+export declare function injectReporter(): (c: HonoContext<HonoNodeEnv>, next: Next) => Promise<void>;
+export declare function initReporter(entryName: string): (c: HonoContext<HonoNodeEnv>, next: Next) => Promise<void>;
+export declare function injectLogger(inputLogger: Logger): (c: HonoContext<HonoNodeEnv>, next: Next) => Promise<void>;

package/dist/types/base/middlewares/renderHandler/index.d.ts

@@ -0,0 +1,9 @@
+import { Render } from '../../../core/render';
+import { ServerBaseOptions } from '../../../core/server';
+import { ServerBase } from '../../serverBase';
+export type BindRenderHandleOptions = {
+    metaName?: string;
+    staticGenerate?: boolean;
+};
+export declare function getRenderHandler(options: ServerBaseOptions & BindRenderHandleOptions): Render | null;
+export declare function bindRenderHandler(server: ServerBase, options: ServerBaseOptions & BindRenderHandleOptions): Promise<void>;

package/dist/types/base/middlewares/renderHandler/render.d.ts

@@ -0,0 +1,12 @@
+import { ServerRoute } from '@modern-js/types';
+import { Render } from '../../../core/render';
+interface CreateRenderOptions {
+    routes: ServerRoute[];
+    pwd: string;
+    staticGenerate?: boolean;
+    metaName?: string;
+    forceCSR?: boolean;
+    nonce?: string;
+}
+export declare function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce, }: CreateRenderOptions): Render;
+export {};

package/dist/types/base/middlewares/renderHandler/serverTiming.d.ts

@@ -0,0 +1,7 @@
+import { ServerTiming as ServerTimingInterafce } from '@modern-js/types';
+export declare class ServerTiming implements ServerTimingInterafce {
+    private headers;
+    private meta;
+    constructor(headers: Headers, meta: string);
+    addServeTiming(name: string, dur: number, desc?: string): this;
+}

package/dist/types/base/middlewares/renderHandler/ssrCache.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node/http" />
+/// <reference types="dist/types/core/server" />
+import type { IncomingMessage } from 'http';
+import { Readable } from 'stream';
+import type { CacheControl, CacheOption, Container } from '@modern-js/types';
+import type { SSRServerContext, ServerRender } from '../../../core/server';
+declare class ServerCache {
+    customContainer?: Container;
+    cacheOption?: CacheOption;
+    private cacheManger?;
+    loadCacheMod(pwd?: string): Promise<void>;
+    matchCacheControl(req?: IncomingMessage): CacheControl | Promise<CacheControl> | undefined;
+    getCache(req: Request, cacheControl: CacheControl, render: ServerRender, ssrContext: SSRServerContext): Promise<string | Readable | ReadableStream<any>>;
+}
+export declare const ssrCache: ServerCache;
+export {};

package/dist/types/base/middlewares/renderHandler/ssrRender.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node/http" />
+/// <reference types="dist/types/core/server" />
+import type { IncomingMessage } from 'http';
+import type { Logger, Reporter, ServerRoute } from '@modern-js/types';
+interface SSRRenderOptions {
+    pwd: string;
+    mode: 'string' | 'stream';
+    html: string;
+    routeInfo: ServerRoute;
+    staticGenerate: boolean;
+    metaName: string;
+    logger: Logger;
+    reporter?: Reporter;
+    nodeReq?: IncomingMessage;
+    nonce?: string;
+}
+export declare function ssrRender(request: Request, { routeInfo, pwd, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, }: SSRRenderOptions): Promise<Response>;
+export {};

package/dist/types/base/serverBase.d.ts

@@ -0,0 +1,49 @@
+import { Hono } from 'hono';
+import { ServerHookRunner } from '../core';
+import { HonoEnv, ServerBaseOptions } from '../core/server';
+declare module '@modern-js/types' {
+    interface ISAppContext {
+        serverBase?: ServerBase;
+    }
+}
+export declare class ServerBase<E extends HonoEnv = any> {
+    options: ServerBaseOptions;
+    runner: ServerHookRunner;
+    private app;
+    private serverConfig;
+    constructor(options: ServerBaseOptions);
+    /**
+     * 初始化顺序
+     * - 获取 server runtime config
+     * - 设置 context
+     * - 创建 hooksRunner
+     * - 合并插件，内置插件和 serverConfig 中配置的插件
+     * - 执行 config hook
+     * - 获取最终的配置
+     * - 设置配置到 context
+     * - 执行 prepare hook
+     */
+    init(): Promise<this>;
+    private createHookRunner;
+    private initServerConfig;
+    private injectContext;
+    private initAppContext;
+    /**
+     * Execute config hooks
+     * @param runner
+     * @param options
+     */
+    private runConfigHook;
+    private initConfig;
+    get all(): import("hono/types").HandlerInterface<E, "all", {}, "/">;
+    get use(): import("hono/types").MiddlewareHandlerInterface<E, {}, "/">;
+    get get(): import("hono/types").HandlerInterface<E, "get", {}, "/">;
+    get post(): import("hono/types").HandlerInterface<E, "post", {}, "/">;
+    get put(): import("hono/types").HandlerInterface<E, "put", {}, "/">;
+    get delete(): import("hono/types").HandlerInterface<E, "delete", {}, "/">;
+    get patch(): import("hono/types").HandlerInterface<E, "patch", {}, "/">;
+    get handle(): (request: Request, Env?: {} | E["Bindings"] | undefined, executionCtx?: import("hono/dist/types/context").ExecutionContext | undefined) => Response | Promise<Response>;
+    get request(): (input: RequestInfo | URL, requestInit?: RequestInit | undefined, Env?: {} | E["Bindings"] | undefined, executionCtx?: import("hono/dist/types/context").ExecutionContext | undefined) => Response | Promise<Response>;
+    get notFound(): (handler: import("hono").NotFoundHandler<E>) => Hono<E, {}, "/">;
+    get onError(): (handler: import("hono").ErrorHandler<E>) => Hono<E, {}, "/">;
+}

package/dist/types/base/utils/debug.d.ts

@@ -0,0 +1 @@
+export declare const debug: import("@modern-js/utils/compiled/debug").Debugger;

package/dist/types/base/utils/entry.d.ts

@@ -0,0 +1,2 @@
+import { ServerRoute } from '@modern-js/types';
+export declare const sortRoutes: (route1: ServerRoute, route2: ServerRoute) => number;

package/dist/types/base/utils/env.d.ts

@@ -0,0 +1,2 @@
+export declare const getRuntimeEnv: () => "node" | "other";
+export declare const checkIsProd: () => boolean;

package/dist/types/base/utils/error.d.ts

@@ -0,0 +1 @@
+export declare const createErrorHtml: (status: number) => string;

package/dist/types/base/utils/index.d.ts

@@ -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/types/base/utils/middlewareCollector.d.ts

@@ -0,0 +1,12 @@
+export type CollectMiddlewaresResult = {
+    web: any[];
+    api: any[];
+};
+export declare const mergeExtension: (users: any[]) => {
+    middleware: any[];
+};
+export declare const createMiddlewareCollecter: () => {
+    getMiddlewares: () => CollectMiddlewaresResult;
+    addWebMiddleware: (input: any) => void;
+    addAPIMiddleware: (input: any) => void;
+};

package/dist/types/base/utils/path.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import type Path from 'path';
+export declare function getPathModule(): Promise<Path.PlatformPath>;

package/dist/types/base/utils/request.d.ts

@@ -0,0 +1,12 @@
+export declare function parseQuery(request: Request): Record<string, string>;
+export declare function parseHeaders(request: Request): Record<string, string | undefined>;
+/**
+ * The function is modified based on
+ * https://github.com/honojs/hono/blob/main/src/utils/url.ts
+ *
+ * MIT Licensed
+ * https://github.com/honojs/hono/blob/main/LICENSE
+ *
+ */
+export declare function getPathname(request: Request): string;
+export declare function getHost(request: Request): string;

package/dist/types/base/utils/serverConfig.d.ts

@@ -0,0 +1,14 @@
+import { ServerConfig } from '../../core/plugin';
+import { ServerOptions } from '../../types/config';
+export declare const getServerConfigPath: (distDirectory: string, serverConfigFile?: string) => Promise<string>;
+export declare const requireConfig: (serverConfigPath: string) => any;
+/**
+ * 对配置进行合并，开发环境下，cliConfig 与 serverConfig 进行深合并
+ * 生产环境下，resolvedConfig 与 serverConfig 进行深合并
+ * resolvedConfigPath: 构建序列化后的 modern.config.js 文件路径
+ */
+export declare const loadConfig: ({ cliConfig, serverConfig, resolvedConfigPath, }: {
+    cliConfig: ServerOptions;
+    serverConfig: ServerConfig;
+    resolvedConfigPath: string;
+}) => any;

package/dist/types/base/utils/transformStream.d.ts

@@ -0,0 +1,2 @@
+import { MaybeAsync } from '@modern-js/plugin';
+export declare function createTransformStream(fn: (content: string) => MaybeAsync<string>): TransformStream<any, any>;

package/dist/types/base/utils/warmup.d.ts

@@ -0,0 +1 @@
+export declare function warmup(bundles: Array<string | undefined>): void;

package/dist/types/core/hono.d.ts

@@ -0,0 +1 @@
+export type { NotFoundHandler, Context as HonoContext, Env as HonoEnv, HonoRequest, Next, MiddlewareHandler as HonoMiddleware, } from 'hono';

package/dist/types/core/index.d.ts

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

package/dist/types/{loadPlugins.d.ts → core/loadPlugins.d.ts}

@@ -1,5 +1,5 @@
 import { InternalPlugins } from '@modern-js/types';
-import { createPlugin, ServerPlugin } from './plugin';
+import { createPlugin, ServerPlugin } from '../core/plugin';
 export declare const loadPlugins: (appDirectory: string, configPlugins: ServerPlugin[], options: {
     internalPlugins?: InternalPlugins;
 }) => ReturnType<typeof createPlugin>[];

package/dist/types/{plugin.d.ts → core/plugin.d.ts}

@@ -1,13 +1,15 @@
 /// <reference types="node" />
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse } from 'http';
-import { Readable } from 'stream';
+import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Component } from 'react';
-import { CommonAPI, ToThreads, AsyncSetup, PluginOptions } from '@modern-js/plugin';
+import { CommonAPI, ToThreads, AsyncSetup, PluginOptions, ToRunners } from '@modern-js/plugin';
 import type { ModernServerContext, BaseSSRServerContext, AfterMatchContext, AfterRenderContext, MiddlewareContext, ISAppContext, ServerRoute, HttpMethodDecider, ServerInitHookContext, AfterStreamingRenderContext } from '@modern-js/types';
-import type { BffUserConfig, ServerOptions, UserConfig } from './types/config';
+import type { BffUserConfig, ServerOptions, UserConfig } from '../types/config';
+import { HonoMiddleware } from './hono';
+import { Render } from './render';
 export type WebAdapter = (ctx: MiddlewareContext) => void | Promise<void>;
-export type Adapter = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+export type NodeRequest = IncomingMessage;
+export type NodeResponse = ServerResponse;
+export type Adapter = (req: NodeRequest, res: NodeResponse) => void | Promise<void>;
 export type WebServerStartInput = {
     pwd: string;
     config: Record<string, any>;
@@ -20,7 +22,7 @@ export type APIServerStartInput = {
     config?: {
         middleware?: Array<any>;
     };
-    render?: (req: IncomingMessage, res: ServerResponse, url?: string) => Promise<string | Readable | null>;
+    render?: Render | null;
 };
 type Change = {
     filename: string;
@@ -59,12 +61,11 @@ declare const serverHooks: {
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
@@ -111,6 +112,8 @@ declare const serverHooks: {
 export type ServerHooks = typeof serverHooks;
 /** All hook callbacks of server plugin. */
 export type ServerHookCallbacks = ToThreads<ServerHooks>;
+/** The ServerHook Runner type */
+export type ServerHookRunner = ToRunners<ServerHooks>;
 /** All apis for server plugin. */
 export type PluginAPI = typeof pluginAPI & CommonAPI<ServerHooks>;
 export declare const createServerManager: () => import("@modern-js/plugin").AsyncManager<{
@@ -124,12 +127,11 @@ export declare const createServerManager: () => import("@modern-js/plugin").Asyn
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
@@ -187,12 +189,11 @@ export declare const serverManager: import("@modern-js/plugin").AsyncManager<{
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
@@ -256,12 +257,11 @@ export declare const createPlugin: (setup?: AsyncSetup<{
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
@@ -318,12 +318,11 @@ export declare const createPlugin: (setup?: AsyncSetup<{
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
@@ -376,12 +375,11 @@ export declare const createPlugin: (setup?: AsyncSetup<{
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
@@ -438,12 +436,11 @@ export declare const createPlugin: (setup?: AsyncSetup<{
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;

package/dist/types/core/render.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'node:http';
+import { Logger, Reporter } from '@modern-js/types';
+export interface RenderOptions {
+    logger: Logger;
+    /** ssr render html templates */
+    tpls: Record<string, string>;
+    reporter?: Reporter;
+    nodeReq?: IncomingMessage;
+}
+export type Render = (request: Request, options: RenderOptions) => Promise<Response>;

package/dist/types/core/server.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { IncomingMessage, Server, ServerResponse } from 'node:http';
+import { Readable } from 'node:stream';
+import type { Metrics, Logger, NextFunction, ModernServerContext, InternalPlugins, Reporter, BaseSSRServerContext, ServerRoute } from '@modern-js/types';
+import { MiddlewareHandler } from 'hono';
+import { ServerOptions } from '../types/config/index';
+import { ServerHookRunner, ServerPlugin } from './plugin';
+import { HonoEnv } from './hono';
+declare module 'http' {
+    interface IncomingMessage {
+        logger: Logger;
+        metrics: Metrics;
+        reporter?: Reporter;
+        body?: any;
+    }
+    interface OutgoingMessage {
+        set: (key: string, value: any) => this;
+        modernFlushedHeaders?: boolean;
+    }
+}
+export type ServerBaseOptions = {
+    /** server working directory, and then also dist directory */
+    pwd: string;
+    config: ServerOptions;
+    serverConfigFile?: string;
+    routes?: ServerRoute[];
+    plugins?: ServerPlugin[];
+    internalPlugins?: InternalPlugins;
+    appContext: {
+        appDirectory?: string;
+        sharedDirectory?: string;
+        apiDirectory?: string;
+        lambdaDirectory?: string;
+    };
+    runMode?: 'apiOnly' | 'ssrOnly' | 'webOnly';
+};
+export type SSRServerContext = BaseSSRServerContext & {
+    staticGenerate?: boolean;
+};
+export type ServerRender = (ssrContext: SSRServerContext) => Promise<string | Readable | ReadableStream>;
+export type RenderResult = {
+    content: string | Buffer;
+    contentType: string;
+    contentStream?: Readable;
+    statusCode?: number;
+    redirect?: boolean;
+};
+export type ConfWithBFF = {
+    bff?: {
+        prefix: string;
+    } & ServerOptions['bff'];
+};
+export type Then<T> = T extends PromiseLike<infer U> ? U : T;
+export type { Metrics, Logger, NextFunction };
+export type HookNames = 'afterMatch' | 'afterRender';
+export interface ModernServerInterface {
+    pwd: string;
+    distDir: string;
+    onInit: (runner: ServerHookRunner, app: Server) => Promise<void>;
+    getRequestHandler: () => (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
+    createHTTPServer: (handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void) => Promise<Server>;
+    render: (req: IncomingMessage, res: ServerResponse, url?: string) => Promise<string | Readable | null>;
+    close?: () => Promise<void>;
+}
+export type ServerConstructor = (options: ServerBaseOptions) => ModernServerInterface;
+export type ModernServerHandler = (context: ModernServerContext, next: NextFunction) => Promise<void> | void;
+export type Middleware<Env extends HonoEnv = any> = MiddlewareHandler<Env>;
+export type RequestHandler = (request: Request, ...args: any[]) => Response | Promise<Response>;
+export * from './hono';

package/dist/types/index.d.ts

@@ -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';