@modern-js/plugin-bff 2.69.5 → 3.0.0-alpha.0

package/dist/esm-node/runtime/hono/adapter.mjs

@@ -0,0 +1,95 @@
+import { Hono } from "@modern-js/server-core";
+import { isProd, logger } from "@modern-js/utils";
+import createHonoRoutes from "../../utils/createHonoRoutes.mjs";
+const before = [
+    'custom-server-hook',
+    'custom-server-middleware',
+    'render'
+];
+class HonoAdapter {
+    wrapInArray(handler) {
+        if (Array.isArray(handler)) return handler;
+        return [
+            handler
+        ];
+    }
+    constructor(api){
+        this.apiMiddleware = [];
+        this.apiServer = null;
+        this.isHono = true;
+        this.setHandlers = async ()=>{
+            if (!this.isHono) return;
+            const { apiHandlerInfos } = this.api.getServerContext();
+            const honoHandlers = createHonoRoutes(apiHandlerInfos);
+            this.apiMiddleware = honoHandlers.map(({ path, method, handler })=>({
+                    name: 'hono-bff-api',
+                    path,
+                    method,
+                    handler,
+                    order: 'post',
+                    before
+                }));
+        };
+        this.registerApiRoutes = async ()=>{
+            if (!this.isHono) return;
+            this.apiServer = new Hono();
+            this.apiMiddleware.forEach(({ path = '*', method = 'all', handler })=>{
+                const handlers = this.wrapInArray(handler);
+                if (0 === handlers.length) return;
+                const firstHandler = handlers[0];
+                const restHandlers = handlers.slice(1);
+                const m = method;
+                const server = this.apiServer;
+                if (!server) return;
+                const register = server[m];
+                register.call(server, path, firstHandler, ...restHandlers);
+            });
+            this.apiServer.onError(async (err, c)=>{
+                try {
+                    const serverConfig = this.api.getServerConfig();
+                    const onErrorHandler = serverConfig?.onError;
+                    if (onErrorHandler) {
+                        const result = await onErrorHandler(err, c);
+                        if (result instanceof Response) return result;
+                    } else logger.error(err);
+                } catch (configError) {
+                    logger.error(`Error in serverConfig.onError handler: ${configError}`);
+                }
+                return c.json({
+                    message: err?.message || '[BFF] Internal Server Error'
+                }, err?.status || 500);
+            });
+        };
+        this.registerMiddleware = async (options)=>{
+            const { prefix } = options;
+            const { bffRuntimeFramework } = this.api.getServerContext();
+            if ('hono' !== bffRuntimeFramework) {
+                this.isHono = false;
+                return;
+            }
+            const { middlewares: globalMiddlewares } = this.api.getServerContext();
+            await this.setHandlers();
+            if (isProd()) globalMiddlewares.push(...this.apiMiddleware);
+            else {
+                await this.registerApiRoutes();
+                const dynamicApiMiddleware = {
+                    name: 'dynamic-bff-handler',
+                    path: `${prefix}/*`,
+                    method: 'all',
+                    order: 'post',
+                    before,
+                    handler: async (c, next)=>{
+                        if (this.apiServer) {
+                            const response = await this.apiServer.fetch(c.req.raw, c.env);
+                            if (404 !== response.status) return new Response(response.body, response);
+                        }
+                        await next();
+                    }
+                };
+                globalMiddlewares.push(dynamicApiMiddleware);
+            }
+        };
+        this.api = api;
+    }
+}
+export { HonoAdapter };

package/dist/{esm/runtime/hono/index.js → esm-node/runtime/hono/index.mjs}

@@ -1,6 +1,4 @@
-export * from "@modern-js/bff-core";
 import { useHonoContext } from "@modern-js/server-core";
-export * from "./operators";
-export {
-  useHonoContext
-};
+export * from "@modern-js/bff-core";
+export * from "./operators.mjs";
+export { useHonoContext };

package/dist/esm-node/runtime/hono/operators.mjs

@@ -0,0 +1,31 @@
+import { useHonoContext } from "@modern-js/server-core";
+const Pipe = (func)=>({
+        name: 'pipe',
+        async execute (executeHelper, next) {
+            const { inputs } = executeHelper;
+            const ctx = useHonoContext();
+            const { res } = ctx;
+            if ('function' == typeof func) {
+                let isPiped = true;
+                const end = (value)=>{
+                    isPiped = false;
+                    if ('function' == typeof value) return void value(res);
+                    return value;
+                };
+                const output = await func(inputs, end);
+                if (!isPiped) if (output) return executeHelper.result = output;
+                else return;
+                executeHelper.inputs = output;
+                await next();
+            }
+        }
+    });
+const Middleware = (middleware)=>({
+        name: 'middleware',
+        metadata (helper) {
+            const middlewares = helper.getMetadata('pipe') || [];
+            middlewares.push(middleware);
+            helper.setMetadata('middleware', middlewares);
+        }
+    });
+export { Middleware, Pipe };

package/dist/esm-node/server.mjs

@@ -0,0 +1,122 @@
+import path from "path";
+import { ApiRouter } from "@modern-js/bff-core";
+import { API_DIR, isFunction, isProd, isWebOnly, requireExistModule } from "@modern-js/utils";
+import { API_APP_NAME } from "./constants.mjs";
+import { HonoAdapter } from "./runtime/hono/adapter.mjs";
+class Storage {
+    reset() {
+        this.middlewares = [];
+    }
+    constructor(){
+        this.middlewares = [];
+    }
+}
+const createTransformAPI = (storage)=>({
+        addMiddleware (fn) {
+            storage.middlewares.push(fn);
+        }
+    });
+const server = ()=>({
+        name: '@modern-js/plugin-bff',
+        setup: (api)=>{
+            const storage = new Storage();
+            const transformAPI = createTransformAPI(storage);
+            let apiAppPath = '';
+            let apiRouter;
+            const honoAdapter = new HonoAdapter(api);
+            api.onPrepare(async ()=>{
+                const appContext = api.getServerContext();
+                const { appDirectory, distDirectory, render } = appContext;
+                const root = isProd() ? distDirectory : appDirectory;
+                const apiPath = path.resolve(root || process.cwd(), API_DIR);
+                apiAppPath = path.resolve(apiPath, API_APP_NAME);
+                const apiMod = await requireExistModule(apiAppPath);
+                if (apiMod && 'function' == typeof apiMod) apiMod(transformAPI);
+                const { middlewares } = storage;
+                api.updateServerContext({
+                    ...appContext,
+                    apiMiddlewares: middlewares
+                });
+                const config = api.getServerConfig();
+                const prefix = config?.bff?.prefix || '/api';
+                const enableHandleWeb = config?.bff?.enableHandleWeb;
+                const httpMethodDecider = config?.bff?.httpMethodDecider;
+                const { distDirectory: pwd, middlewares: globalMiddlewares } = api.getServerContext();
+                const webOnly = await isWebOnly();
+                let handler;
+                if (webOnly) handler = async (c, next)=>{
+                    c.body('');
+                    await next();
+                };
+                else {
+                    const runner = api.getHooks();
+                    const renderHandler = enableHandleWeb ? render : null;
+                    handler = await runner.prepareApiServer.call({
+                        pwd: pwd,
+                        prefix,
+                        render: renderHandler,
+                        httpMethodDecider
+                    });
+                }
+                if (handler && isFunction(handler)) globalMiddlewares.push({
+                    name: 'bind-bff',
+                    handler: (c, next)=>{
+                        if (!c.req.path.startsWith(prefix) && !enableHandleWeb) return next();
+                        return handler(c, next);
+                    },
+                    order: 'post',
+                    before: [
+                        'custom-server-hook',
+                        'custom-server-middleware',
+                        'render'
+                    ]
+                });
+                honoAdapter.registerMiddleware({
+                    prefix,
+                    enableHandleWeb
+                });
+            });
+            api.onReset(async ({ event })=>{
+                storage.reset();
+                const appContext = api.getServerContext();
+                const newApiModule = await requireExistModule(apiAppPath);
+                if (newApiModule && 'function' == typeof newApiModule) newApiModule(transformAPI);
+                const { middlewares } = storage;
+                api.updateServerContext({
+                    ...appContext,
+                    apiMiddlewares: middlewares
+                });
+                if ('file-change' === event.type) {
+                    const apiHandlerInfos = await apiRouter.getApiHandlers();
+                    const appContext = api.getServerContext();
+                    api.updateServerContext({
+                        ...appContext,
+                        apiHandlerInfos
+                    });
+                    await honoAdapter.setHandlers();
+                    await honoAdapter.registerApiRoutes();
+                }
+            });
+            api.prepareApiServer(async (input, next)=>{
+                const { pwd, prefix, httpMethodDecider } = input;
+                const apiDir = path.resolve(pwd, API_DIR);
+                const appContext = api.getServerContext();
+                const { apiDirectory, lambdaDirectory } = appContext;
+                apiRouter = new ApiRouter({
+                    appDir: pwd,
+                    apiDir: apiDirectory || apiDir,
+                    lambdaDir: lambdaDirectory,
+                    prefix,
+                    httpMethodDecider
+                });
+                const apiHandlerInfos = await apiRouter.getApiHandlers();
+                api.updateServerContext({
+                    ...appContext,
+                    apiRouter,
+                    apiHandlerInfos
+                });
+                return next(input);
+            });
+        }
+    });
+export { server as default };

package/dist/esm-node/utils/clientGenerator.mjs

@@ -0,0 +1,175 @@
+import path from "path";
+import { generateClient } from "@modern-js/bff-core";
+import { fs, logger } from "@modern-js/utils";
+const API_DIR = 'api';
+const PLUGIN_DIR = 'plugin';
+const RUNTIME_DIR = 'runtime';
+const CLIENT_DIR = 'client';
+const EXPORT_PREFIX = `./${API_DIR}/`;
+const TYPE_PREFIX = `${API_DIR}/`;
+const toPosixPath = (p)=>p.replace(/\\/g, '/');
+const posixJoin = (...args)=>toPosixPath(path.join(...args));
+async function readDirectoryFiles(appDirectory, directory, relativeDistPath) {
+    const filesList = [];
+    async function readFiles(currentPath) {
+        const entries = await fs.readdir(currentPath, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if ('_app.ts' === entry.name) continue;
+            const resourcePath = path.join(currentPath, entry.name);
+            if (entry.isDirectory()) await readFiles(resourcePath);
+            else {
+                const source = await fs.readFile(resourcePath, 'utf8');
+                const relativePath = path.relative(directory, resourcePath);
+                const parsedPath = path.parse(relativePath);
+                const targetDir = posixJoin(`./${relativeDistPath}/${CLIENT_DIR}`, parsedPath.dir, `${parsedPath.name}.js`);
+                const name = parsedPath.name;
+                const absTargetDir = path.resolve(targetDir);
+                const relativePathFromAppDirectory = path.relative(appDirectory, currentPath);
+                const typesFilePath = posixJoin(`./${relativeDistPath}`, relativePathFromAppDirectory, `${name}.d.ts`);
+                const relativeTargetDistDir = `./${typesFilePath}`;
+                const exportKey = toPosixPath(path.join(parsedPath.dir, name));
+                filesList.push({
+                    resourcePath,
+                    source,
+                    targetDir,
+                    name,
+                    absTargetDir,
+                    relativeTargetDistDir,
+                    exportKey
+                });
+            }
+        }
+    }
+    await readFiles(directory);
+    return filesList;
+}
+function mergePackageJson(packageJson, files, typesVersion, exports) {
+    packageJson.files = [
+        ...new Set([
+            ...packageJson.files || [],
+            ...files
+        ])
+    ];
+    packageJson.typesVersions ??= {};
+    const starTypes = packageJson.typesVersions['*'] || {};
+    Object.keys(starTypes).forEach((k)=>k.startsWith(TYPE_PREFIX) && delete starTypes[k]);
+    packageJson.typesVersions['*'] = {
+        ...starTypes,
+        ...typesVersion['*'] || {}
+    };
+    packageJson.exports ??= {};
+    Object.keys(packageJson.exports).forEach((k)=>k.startsWith(EXPORT_PREFIX) && delete packageJson.exports[k]);
+    Object.assign(packageJson.exports, exports);
+}
+async function writeTargetFile(absTargetDir, content) {
+    await fs.mkdir(path.dirname(absTargetDir), {
+        recursive: true
+    });
+    await fs.writeFile(absTargetDir, content);
+}
+async function setPackage(files, appDirectory, relativeDistPath) {
+    try {
+        const packagePath = path.resolve(appDirectory, './package.json');
+        const packageContent = await fs.readFile(packagePath, 'utf8');
+        const packageJson = JSON.parse(packageContent);
+        const addFiles = [
+            posixJoin(relativeDistPath, CLIENT_DIR, '**', '*'),
+            posixJoin(relativeDistPath, RUNTIME_DIR, '**', '*'),
+            posixJoin(relativeDistPath, PLUGIN_DIR, '**', '*')
+        ];
+        const typesVersions = {
+            '*': files.reduce((acc, file)=>{
+                const typeFilePath = toPosixPath(`./${file.targetDir}`).replace('js', 'd.ts');
+                return {
+                    ...acc,
+                    [toPosixPath(`${TYPE_PREFIX}${file.exportKey}`)]: [
+                        typeFilePath
+                    ]
+                };
+            }, {
+                [`${API_DIR}/*`]: [
+                    toPosixPath(`./${relativeDistPath}/${CLIENT_DIR}/*.d.ts`)
+                ],
+                [RUNTIME_DIR]: [
+                    toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.d.ts`)
+                ],
+                [PLUGIN_DIR]: [
+                    toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.d.ts`)
+                ]
+            })
+        };
+        const exports = files.reduce((acc, file)=>{
+            const exportKey = `${EXPORT_PREFIX}${file.exportKey}`;
+            const jsFilePath = toPosixPath(`./${file.targetDir}`);
+            return {
+                ...acc,
+                [toPosixPath(exportKey)]: {
+                    import: jsFilePath,
+                    types: toPosixPath(jsFilePath.replace(/\.js$/, '.d.ts'))
+                }
+            };
+        }, {
+            [toPosixPath(`./${API_DIR}/*`)]: {
+                import: toPosixPath(`./${relativeDistPath}/${CLIENT_DIR}/*.js`),
+                types: toPosixPath(`./${relativeDistPath}/${CLIENT_DIR}/*.d.ts`)
+            },
+            [toPosixPath(`./${PLUGIN_DIR}`)]: {
+                import: toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.js`),
+                require: toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.js`),
+                types: toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.d.ts`)
+            },
+            [toPosixPath(`./${RUNTIME_DIR}`)]: {
+                import: toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.js`),
+                require: toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.js`),
+                types: toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.d.ts`)
+            }
+        });
+        mergePackageJson(packageJson, addFiles, typesVersions, exports);
+        await fs.promises.writeFile(packagePath, JSON.stringify(packageJson, null, 2));
+    } catch (error) {
+        logger.error(`package.json update failed: ${error}`);
+    }
+}
+async function copyFiles(from, to) {
+    if (await fs.pathExists(from)) await fs.copy(toPosixPath(from), toPosixPath(to));
+}
+async function clientGenerator(draftOptions) {
+    const sourceList = await readDirectoryFiles(draftOptions.appDir, draftOptions.lambdaDir, draftOptions.relativeDistPath);
+    const getClitentCode = async (resourcePath, source)=>{
+        const warning = `The file ${resourcePath} is not allowd to be imported in src directory, only API definition files are allowed.`;
+        if (!draftOptions.existLambda) return void logger.warn(warning);
+        const options = {
+            prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
+            appDir: draftOptions.appDir,
+            apiDir: draftOptions.apiDir,
+            lambdaDir: draftOptions.lambdaDir,
+            port: Number(draftOptions.port),
+            source,
+            resourcePath,
+            target: 'bundle',
+            httpMethodDecider: draftOptions.httpMethodDecider,
+            requestCreator: draftOptions.requestCreator
+        };
+        const { lambdaDir } = draftOptions;
+        if (!resourcePath.startsWith(lambdaDir)) return void logger.warn(warning);
+        const result = await generateClient(options);
+        return result;
+    };
+    try {
+        for (const source of sourceList){
+            const code = await getClitentCode(source.resourcePath, source.source);
+            if (code?.value) {
+                await writeTargetFile(source.absTargetDir, code.value);
+                await copyFiles(source.relativeTargetDistDir, source.targetDir.replace("js", 'd.ts'));
+            }
+        }
+        logger.info("Client bundle generate succeed");
+    } catch (error) {
+        logger.error(`Client bundle generate failed: ${error}`);
+    }
+    setPackage(sourceList, draftOptions.appDir, draftOptions.relativeDistPath);
+}
+const utils_clientGenerator = clientGenerator;
+export { copyFiles, utils_clientGenerator as default, readDirectoryFiles };

package/dist/esm-node/utils/createHonoRoutes.mjs

@@ -0,0 +1,91 @@
+import { HttpMetadata, ResponseMetaType, ValidationError, isWithMetaHandler } from "@modern-js/bff-core";
+import { parse } from "@modern-js/create-request/qs";
+import type_is from "type-is";
+const createHonoRoutes = (handlerInfos = [])=>handlerInfos.map(({ routePath, handler, httpMethod })=>{
+        const routeMiddlwares = Reflect.getMetadata('middleware', handler) || [];
+        const honoHandler = createHonoHandler(handler);
+        return {
+            method: httpMethod.toLowerCase(),
+            path: routePath,
+            handler: routeMiddlwares.length > 0 ? [
+                ...routeMiddlwares,
+                honoHandler
+            ] : honoHandler
+        };
+    });
+const handleResponseMeta = (c, handler)=>{
+    const responseMeta = Reflect.getMetadata(HttpMetadata.Response, handler);
+    if (Array.isArray(responseMeta)) for (const meta of responseMeta)switch(meta.type){
+        case ResponseMetaType.Headers:
+            for (const [key, value] of Object.entries(meta.value))c.header(key, value);
+            break;
+        case ResponseMetaType.Redirect:
+            return c.redirect(meta.value);
+        case ResponseMetaType.StatusCode:
+            c.status(meta.value);
+            break;
+        default:
+            break;
+    }
+    return null;
+};
+const createHonoHandler = (handler)=>async (c)=>{
+        const input = await getHonoInput(c);
+        if (isWithMetaHandler(handler)) try {
+            const response = handleResponseMeta(c, handler);
+            if (response) return response;
+            if (c.finalized) return;
+            const result = await handler(input);
+            if (result instanceof Response) return result;
+            return result && 'object' == typeof result ? c.json(result) : c.body(result);
+        } catch (error) {
+            if (error instanceof ValidationError) {
+                c.status(error.status);
+                return c.json({
+                    message: error.message
+                });
+            }
+            throw error;
+        }
+        {
+            const routePath = c.req.routePath;
+            const paramNames = routePath.match(/:\w+/g)?.map((s)=>s.slice(1)) || [];
+            const params = Object.fromEntries(paramNames.map((name)=>[
+                    name,
+                    input.params[name]
+                ]));
+            const args = Object.values(params).concat(input);
+            const body = await handler(...args);
+            if (c.finalized) return await Promise.resolve();
+            if (void 0 !== body) {
+                if (body instanceof Response) return body;
+                return c.json(body);
+            }
+        }
+    };
+const getHonoInput = async (c)=>{
+    const draft = {
+        params: c.req.param(),
+        query: parse(c.req.query()),
+        headers: c.req.header(),
+        cookies: c.req.header('cookie')
+    };
+    try {
+        const contentType = c.req.header('content-type') || '';
+        if (type_is.is(contentType, [
+            'application/json'
+        ])) draft.data = await c.req.json();
+        else if (type_is.is(contentType, [
+            'multipart/form-data'
+        ])) draft.formData = await c.req.parseBody();
+        else if (type_is.is(contentType, [
+            'application/x-www-form-urlencoded'
+        ])) draft.formUrlencoded = await c.req.parseBody();
+        else draft.body = await c.req.json();
+    } catch (error) {
+        draft.body = null;
+    }
+    return draft;
+};
+const utils_createHonoRoutes = createHonoRoutes;
+export { createHonoHandler, utils_createHonoRoutes as default };

package/dist/esm-node/utils/crossProjectApiPlugin.mjs

@@ -0,0 +1,34 @@
+import path from "path";
+const PACKAGE_NAME = '{packageName}';
+const PREFIX = '{prefix}';
+const API_DIR = '{apiDirectory}';
+const LAMBDA_DIR = '{lambdaDirectory}';
+const DIST_DIR = '{distDirectory}';
+const NODE_MODULES = 'node_modules';
+const crossProjectApiPlugin = ()=>({
+        name: '@modern-js/plugin-independent-bff',
+        post: [
+            '@modern-js/plugin-bff'
+        ],
+        setup: (api)=>{
+            api.modifyResolvedConfig((resolvedConfig)=>{
+                const { appDirectory: originAppDirectory } = api.getAppContext();
+                const sdkPath = path.join(originAppDirectory, NODE_MODULES, PACKAGE_NAME);
+                const sdkDistPath = path.join(sdkPath, DIST_DIR);
+                const apiDirectory = path.join(sdkDistPath, API_DIR);
+                const lambdaDirectory = path.resolve(sdkDistPath, LAMBDA_DIR);
+                api.updateAppContext({
+                    apiDirectory,
+                    lambdaDirectory
+                });
+                const config = api.getConfig();
+                if (config?.bff?.prefix) console.warn(`[WARNING] Detected bff.prefix configuration: "${config.bff.prefix}".
+When using cross-project BFF, you should not configure bff.prefix as it may cause API path conflicts or access issues. Please remove the bff.prefix configuration.`);
+                resolvedConfig.bff.prefix = PREFIX;
+                resolvedConfig.bff.isCrossProjectServer = true;
+                return resolvedConfig;
+            });
+        }
+    });
+const utils_crossProjectApiPlugin = crossProjectApiPlugin;
+export { API_DIR, DIST_DIR, LAMBDA_DIR, PACKAGE_NAME, PREFIX, crossProjectApiPlugin, utils_crossProjectApiPlugin as default };

package/dist/esm-node/utils/pluginGenerator.mjs

@@ -0,0 +1,29 @@
+import path from "path";
+import { fs, logger, normalizeToPosixPath } from "@modern-js/utils";
+import { API_DIR, DIST_DIR, LAMBDA_DIR, PACKAGE_NAME, PREFIX } from "./crossProjectApiPlugin.mjs";
+function replaceContent(source, packageName, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath) {
+    const updatedSource = source.replace(new RegExp(PACKAGE_NAME, 'g'), packageName).replace(new RegExp(PREFIX, 'g'), prefix).replace(new RegExp(DIST_DIR, 'g'), normalizeToPosixPath(relativeDistPath)).replace(new RegExp(API_DIR, 'g'), normalizeToPosixPath(relativeApiPath)).replace(new RegExp(LAMBDA_DIR, 'g'), normalizeToPosixPath(relativeLambdaPath));
+    return updatedSource;
+}
+async function pluginGenerator({ prefix, appDirectory, relativeDistPath, relativeApiPath, relativeLambdaPath }) {
+    try {
+        const packageContent = await fs.readFile(path.resolve(appDirectory, './package.json'), 'utf8');
+        const packageJson = JSON.parse(packageContent);
+        const pluginDir = path.resolve(appDirectory, `./${relativeDistPath}`, 'plugin');
+        const pluginPath = path.join(pluginDir, 'index.js');
+        const pluginTemplate = await fs.readFile(path.resolve(__dirname, 'crossProjectApiPlugin.js'), 'utf8');
+        const updatedPlugin = replaceContent(pluginTemplate, packageJson.name, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath);
+        await fs.ensureFile(pluginPath);
+        await fs.writeFile(pluginPath, updatedPlugin);
+        const typeContent = `import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+      export declare const crossProjectApiPlugin: () => CliPlugin<AppTools>`;
+        const pluginTypePath = path.join(pluginDir, 'index.d.ts');
+        await fs.ensureFile(pluginTypePath);
+        await fs.writeFile(pluginTypePath, typeContent);
+        logger.info('Api plugin generate succeed');
+    } catch (error) {
+        logger.error('Api plugin generate failed:', error);
+    }
+}
+const utils_pluginGenerator = pluginGenerator;
+export { utils_pluginGenerator as default };

package/dist/esm-node/utils/runtimeGenerator.mjs

@@ -0,0 +1,43 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+const getPackageName = (appDirectory)=>{
+    try {
+        const packageJsonPath = path.resolve(appDirectory, './package.json');
+        const packageJson = require(packageJsonPath);
+        return packageJson.name;
+    } catch (error) {
+        return;
+    }
+};
+async function runtimeGenerator({ runtime, appDirectory, relativeDistPath, packageName }) {
+    const pluginDir = path.resolve(appDirectory, `./${relativeDistPath}`, 'runtime');
+    const requestId = packageName || getPackageName(appDirectory) || process.env.npm_package_name || 'default';
+    const source = `import { configure as _configure } from '${runtime}'
+    const configure = (options) => {
+      return _configure({
+        ...options,
+        requestId: '${requestId}',
+      });
+    }
+    export { configure }
+  `;
+    const pluginPath = path.join(pluginDir, 'index.js');
+    await fs.ensureFile(pluginPath);
+    await fs.writeFile(pluginPath, source);
+    const tsSource = `type IOptions<F = typeof fetch> = {
+    request?: F;
+    interceptor?: (request: F) => F;
+    allowedHeaders?: string[];
+    setDomain?: (ops?: {
+      target: 'node' | 'browser';
+      requestId: string;
+    }) => string;
+    requestId?: string;
+  };
+  export declare const configure: (options: IOptions) => void;`;
+    const pluginTypePath = path.join(pluginDir, 'index.d.ts');
+    await fs.ensureFile(pluginTypePath);
+    await fs.writeFile(pluginTypePath, tsSource);
+}
+const utils_runtimeGenerator = runtimeGenerator;
+export { utils_runtimeGenerator as default };

package/dist/types/loader.d.ts

@@ -1,5 +1,5 @@
 import type { HttpMethodDecider } from '@modern-js/types';
-import type { LoaderContext } from 'webpack';
+import type { Rspack } from '@rsbuild/core';
 export type APILoaderOptions = {
     prefix: string;
     appDir: string;
@@ -12,5 +12,5 @@ export type APILoaderOptions = {
     target: string;
     httpMethodDecider?: HttpMethodDecider;
 };
-declare function loader(this: LoaderContext<APILoaderOptions>, source: string): Promise<void>;
+declare function loader(this: Rspack.LoaderContext<APILoaderOptions>, source: string): Promise<void>;
 export default loader;

package/dist/types/runtime/hono/adapter.d.ts

@@ -1,4 +1,4 @@
-import type { MiddlewareHandler, PluginAPI, ServerMiddleware } from '@modern-js/server-core';
+import type { MiddlewareHandler, ServerMiddleware, ServerPluginAPI } from '@modern-js/server-core';
 import { Hono } from '@modern-js/server-core';
 interface MiddlewareOptions {
     prefix: string;
@@ -7,9 +7,9 @@ interface MiddlewareOptions {
 export declare class HonoAdapter {
     apiMiddleware: ServerMiddleware[];
     apiServer: Hono | null;
-    api: PluginAPI;
+    api: ServerPluginAPI;
     isHono: boolean;
-    constructor(api: PluginAPI);
+    constructor(api: ServerPluginAPI);
     setHandlers: () => Promise<void>;
     registerApiRoutes: () => Promise<void>;
     registerMiddleware: (options: MiddlewareOptions) => Promise<void>;

package/dist/types/server.d.ts

@@ -1,3 +1,3 @@
-import type { ServerPluginLegacy } from '@modern-js/server-core';
-declare const _default: () => ServerPluginLegacy;
+import type { ServerPlugin } from '@modern-js/server-core';
+declare const _default: () => ServerPlugin;
 export default _default;