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

package/dist/esm/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/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/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/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";
+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/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/esm-node/cli.mjs

@@ -0,0 +1,214 @@
+import path from "path";
+import { ApiRouter } from "@modern-js/bff-core";
+import { compile } from "@modern-js/server-utils";
+import { API_DIR, DEFAULT_API_PREFIX, SHARED_DIR, fs, normalizeOutputPath } from "@modern-js/utils";
+import clientGenerator from "./utils/clientGenerator.mjs";
+import pluginGenerator from "./utils/pluginGenerator.mjs";
+import runtimeGenerator from "./utils/runtimeGenerator.mjs";
+const TS_CONFIG_FILENAME = 'tsconfig.json';
+const RUNTIME_CREATE_REQUEST = '@modern-js/plugin-bff/client';
+const RUNTIME_HONO = '@modern-js/plugin-bff/server';
+const bffPlugin = ()=>({
+        name: '@modern-js/plugin-bff',
+        setup: (api)=>{
+            const compileApi = async ()=>{
+                const { appDirectory, distDirectory, apiDirectory, sharedDirectory, moduleType } = api.getAppContext();
+                const modernConfig = api.getNormalizedConfig();
+                const distDir = path.resolve(distDirectory);
+                const apiDir = apiDirectory || path.resolve(appDirectory, API_DIR);
+                const sharedDir = sharedDirectory || path.resolve(appDirectory, SHARED_DIR);
+                const tsconfigPath = path.resolve(appDirectory, TS_CONFIG_FILENAME);
+                const sourceDirs = [];
+                if (await fs.pathExists(apiDir)) sourceDirs.push(apiDir);
+                if (await fs.pathExists(sharedDir)) sourceDirs.push(sharedDir);
+                const { server } = modernConfig;
+                const { alias } = modernConfig.source;
+                const { alias: resolveAlias } = modernConfig.resolve;
+                const { babel } = modernConfig.tools;
+                if (sourceDirs.length > 0) {
+                    const combinedAlias = [].concat(alias ?? []).concat(resolveAlias ?? []);
+                    await compile(appDirectory, {
+                        server,
+                        alias: combinedAlias,
+                        babelConfig: babel
+                    }, {
+                        sourceDirs,
+                        distDir,
+                        tsconfigPath,
+                        moduleType,
+                        throwErrorInsteadOfExit: true
+                    });
+                }
+            };
+            const generator = async ()=>{
+                const { appDirectory, apiDirectory, lambdaDirectory, port } = api.getAppContext();
+                const modernConfig = api.getNormalizedConfig();
+                const relativeDistPath = modernConfig?.output?.distPath?.root || 'dist';
+                const { bff } = modernConfig || {};
+                const prefix = bff?.prefix || DEFAULT_API_PREFIX;
+                const httpMethodDecider = bff?.httpMethodDecider;
+                const apiRouter = new ApiRouter({
+                    apiDir: apiDirectory,
+                    appDir: appDirectory,
+                    lambdaDir: lambdaDirectory,
+                    prefix,
+                    httpMethodDecider,
+                    isBuild: true
+                });
+                const lambdaDir = apiRouter.getLambdaDir();
+                const existLambda = apiRouter.isExistLambda();
+                const runtime = bff?.runtimeCreateRequest || RUNTIME_CREATE_REQUEST;
+                const relativeApiPath = path.relative(appDirectory, apiDirectory);
+                const relativeLambdaPath = path.relative(appDirectory, lambdaDir);
+                await pluginGenerator({
+                    prefix,
+                    appDirectory,
+                    relativeDistPath,
+                    relativeApiPath,
+                    relativeLambdaPath
+                });
+                await clientGenerator({
+                    prefix,
+                    appDir: appDirectory,
+                    apiDir: apiDirectory,
+                    lambdaDir,
+                    existLambda,
+                    port,
+                    requestCreator: bff?.requestCreator,
+                    httpMethodDecider,
+                    relativeDistPath,
+                    relativeApiPath
+                });
+                await runtimeGenerator({
+                    runtime,
+                    appDirectory,
+                    relativeDistPath
+                });
+            };
+            const handleCrossProjectInvocation = async (isBuild = false)=>{
+                const { bff } = api.getNormalizedConfig();
+                if (bff?.crossProject) {
+                    if (!isBuild) await compileApi();
+                    await generator();
+                }
+            };
+            const isHono = ()=>{
+                const { bffRuntimeFramework } = api.getAppContext();
+                return 'hono' === bffRuntimeFramework;
+            };
+            const createCompressConfig = (devServer, prefix)=>{
+                if (!devServer || 'object' != typeof devServer || Array.isArray(devServer)) return;
+                const { compress } = devServer;
+                if (void 0 === compress || true === compress) return {
+                    filter: (req)=>!req.url?.includes(prefix)
+                };
+                if (false === compress) return false;
+                return compress;
+            };
+            api.config(async ()=>{
+                const honoRuntimePath = isHono() ? {
+                    [RUNTIME_HONO]: RUNTIME_HONO
+                } : void 0;
+                const devServer = api.getConfig()?.tools?.devServer;
+                const prefix = api.getConfig()?.bff?.prefix || DEFAULT_API_PREFIX;
+                const compress = createCompressConfig(devServer, prefix);
+                return {
+                    tools: {
+                        devServer: {
+                            compress
+                        },
+                        bundlerChain: (chain, { CHAIN_ID, isServer })=>{
+                            const { port, appDirectory, apiDirectory, lambdaDirectory } = api.getAppContext();
+                            const modernConfig = api.getNormalizedConfig();
+                            const { bff } = modernConfig || {};
+                            const prefix = bff?.prefix || DEFAULT_API_PREFIX;
+                            const httpMethodDecider = bff?.httpMethodDecider;
+                            const apiRouter = new ApiRouter({
+                                apiDir: apiDirectory,
+                                appDir: appDirectory,
+                                lambdaDir: lambdaDirectory,
+                                prefix,
+                                httpMethodDecider,
+                                isBuild: true
+                            });
+                            const lambdaDir = apiRouter.getLambdaDir();
+                            const existLambda = apiRouter.isExistLambda();
+                            const apiRegexp = new RegExp(normalizeOutputPath(`${apiDirectory}${path.sep}.*(.[tj]s)$`));
+                            const name = isServer ? 'server' : 'client';
+                            const loaderPath = require.resolve('./loader');
+                            chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(apiRegexp);
+                            chain.module.rule('js-bff-api').test(apiRegexp).use('custom-loader').loader(loaderPath.replace(/\\/g, '/')).options({
+                                prefix,
+                                appDir: appDirectory,
+                                apiDir: apiDirectory,
+                                lambdaDir,
+                                existLambda,
+                                port,
+                                target: name,
+                                requestCreator: bff?.requestCreator,
+                                httpMethodDecider
+                            });
+                        }
+                    },
+                    output: {
+                        externals: honoRuntimePath
+                    }
+                };
+            });
+            api.modifyServerRoutes(({ routes })=>{
+                const modernConfig = api.getNormalizedConfig();
+                const { bff } = modernConfig || {};
+                const prefix = bff?.prefix || '/api';
+                const prefixList = [];
+                if (Array.isArray(prefix)) prefixList.push(...prefix);
+                else prefixList.push(prefix);
+                const apiServerRoutes = prefixList.map((pre)=>({
+                        urlPath: pre,
+                        isApi: true,
+                        entryPath: '',
+                        isSPA: false,
+                        isSSR: false
+                    }));
+                if (!isHono() && bff?.enableHandleWeb) return {
+                    routes: routes.map((route)=>({
+                            ...route,
+                            isApi: true
+                        })).concat(apiServerRoutes)
+                };
+                return {
+                    routes: routes.concat(apiServerRoutes)
+                };
+            });
+            api._internalServerPlugins(({ plugins })=>{
+                plugins.push({
+                    name: '@modern-js/plugin-bff/server-plugin'
+                });
+                return {
+                    plugins
+                };
+            });
+            api.onBeforeDev(async ()=>{
+                await handleCrossProjectInvocation();
+            });
+            api.onAfterBuild(async ()=>{
+                await compileApi();
+                await handleCrossProjectInvocation(true);
+            });
+            api.addWatchFiles(async ()=>{
+                const appContext = api.getAppContext();
+                const config = api.getNormalizedConfig();
+                if (config?.bff?.crossProject) return [
+                    appContext.apiDirectory
+                ];
+                return [];
+            });
+            api.onFileChanged(async (e)=>{
+                const { filename, eventType, isPrivate } = e;
+                const { appDirectory, apiDirectory } = api.getAppContext();
+                const relativeApiPath = path.relative(appDirectory, apiDirectory);
+                if (!isPrivate && ('change' === eventType || 'unlink' === eventType) && filename.startsWith(`${relativeApiPath}/`) && (filename.endsWith('.ts') || filename.endsWith('.js'))) await handleCrossProjectInvocation();
+            });
+        }
+    });
+const cli = bffPlugin;
+export { bffPlugin, cli as default };

package/dist/esm-node/constants.mjs

@@ -0,0 +1,11 @@
+const API_APP_NAME = '_app';
+const BUILD_FILES = [
+    '**/*.[tj]sx?',
+    '!**/*.test.jsx?',
+    '!**/*.test.tsx?',
+    '!**/*.spec.jsx?',
+    '!**/*.spec.tsx?',
+    '!__tests__/*.tsx?',
+    '!__tests__/*.jsx?'
+];
+export { API_APP_NAME, BUILD_FILES };

package/dist/esm-node/index.mjs

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

package/dist/esm-node/loader.mjs

@@ -0,0 +1,39 @@
+import { generateClient } from "@modern-js/bff-core";
+import { logger } from "@modern-js/utils";
+async function loader(source) {
+    this.cacheable();
+    const { resourcePath } = this;
+    delete require.cache[resourcePath];
+    const callback = this.async();
+    const draftOptions = this.getOptions();
+    const warning = `The file ${resourcePath} is not allowd to be imported in src directory, only API definition files are allowed.`;
+    if (!draftOptions.existLambda) {
+        logger.warn(warning);
+        callback(null, `throw new Error('${warning}')`);
+        return;
+    }
+    const options = {
+        prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
+        appDir: draftOptions.appDir,
+        apiDir: draftOptions.apiDir,
+        lambdaDir: draftOptions.lambdaDir,
+        target: draftOptions.target,
+        port: Number(draftOptions.port),
+        source,
+        resourcePath,
+        httpMethodDecider: draftOptions.httpMethodDecider
+    };
+    const { lambdaDir } = draftOptions;
+    if (!resourcePath.startsWith(lambdaDir)) {
+        logger.warn(warning);
+        callback(null, `throw new Error('${warning}')`);
+        return;
+    }
+    if (draftOptions.fetcher) options.fetcher = draftOptions.fetcher;
+    if (draftOptions.requestCreator) options.requestCreator = draftOptions.requestCreator;
+    options.requireResolve = require.resolve;
+    const result = await generateClient(options);
+    callback(void 0, result.isOk ? result.value : `throw new Error('${result.value}')`);
+}
+const src_loader = loader;
+export { src_loader as default };

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

@@ -1,6 +1,2 @@
 import { configure, createRequest, createUploader } from "@modern-js/create-request";
-export {
-  configure,
-  createRequest,
-  createUploader
-};
+export { configure, createRequest, createUploader };