@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.1 → 3.5.0-ultramodern.100

package/dist/cjs/utils/effectSourceLoader.js

@@ -0,0 +1,252 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    bundleEffectEntryForNode: ()=>bundleEffectEntryForNode,
+    loadEffectSourceModule: ()=>loadEffectSourceModule
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+var external_node_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_node_crypto_namespaceObject);
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const external_esbuild_namespaceObject = require("esbuild");
+const dynamicImport = new Function('specifier', 'return import(specifier)');
+const SOURCE_LOADERS = new Map([
+    [
+        '.js',
+        'js'
+    ],
+    [
+        '.jsx',
+        'jsx'
+    ],
+    [
+        '.mjs',
+        'js'
+    ],
+    [
+        '.cjs',
+        'js'
+    ],
+    [
+        '.ts',
+        'ts'
+    ],
+    [
+        '.tsx',
+        'tsx'
+    ],
+    [
+        '.mts',
+        'ts'
+    ],
+    [
+        '.cts',
+        'ts'
+    ]
+]);
+function sourceLoader(args) {
+    return SOURCE_LOADERS.get(external_node_path_default().extname(args.path).toLowerCase());
+}
+function preserveSourceModuleSemantics() {
+    return {
+        name: 'modern-js-effect-source-semantics',
+        setup (buildApi) {
+            buildApi.onLoad({
+                filter: /\.[cm]?[jt]sx?$/
+            }, async (args)=>{
+                const loader = sourceLoader(args);
+                if (!loader) return;
+                const source = await external_node_fs_default().promises.readFile(args.path, 'utf8');
+                const compiled = await (0, external_esbuild_namespaceObject.transform)(source, {
+                    define: {
+                        'import.meta.url': JSON.stringify((0, external_node_url_namespaceObject.pathToFileURL)(args.path).href)
+                    },
+                    jsx: 'automatic',
+                    loader,
+                    sourcefile: args.path,
+                    target: 'node20'
+                });
+                return {
+                    contents: compiled.code,
+                    loader: 'js',
+                    resolveDir: external_node_path_default().dirname(args.path)
+                };
+            });
+        }
+    };
+}
+const nodeBuiltins = new Set([
+    ...external_node_module_namespaceObject.builtinModules,
+    ...external_node_module_namespaceObject.builtinModules.map((name)=>`node:${name}`)
+]);
+const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
+function isBareSpecifier(specifier) {
+    return !specifier.startsWith('.') && !specifier.startsWith('/') && !external_node_path_default().isAbsolute(specifier);
+}
+function externalizeInstalledDependencies() {
+    return {
+        name: 'modern-js-effect-installed-dependencies',
+        setup (buildApi) {
+            buildApi.onResolve({
+                filter: /.*/
+            }, async (args)=>{
+                if (!isBareSpecifier(args.path) || nodeBuiltins.has(args.path) || args.pluginData?.[dependencyResolutionMarker] === true) return nodeBuiltins.has(args.path) ? {
+                    external: true,
+                    path: args.path
+                } : void 0;
+                const resolution = await buildApi.resolve(args.path, {
+                    importer: args.importer,
+                    kind: args.kind,
+                    namespace: args.namespace,
+                    pluginData: {
+                        ...args.pluginData,
+                        [dependencyResolutionMarker]: true
+                    },
+                    resolveDir: args.resolveDir
+                });
+                if (resolution.errors.length > 0) return {
+                    external: true,
+                    path: args.path
+                };
+                if (resolution.external || !resolution.path) return {
+                    external: true,
+                    path: args.path
+                };
+                const realPath = await external_node_fs_default().promises.realpath(resolution.path).catch(()=>resolution.path);
+                if (realPath.includes(`${external_node_path_default().sep}node_modules${external_node_path_default().sep}`)) return {
+                    external: true,
+                    path: args.path
+                };
+                return {
+                    namespace: resolution.namespace,
+                    path: resolution.path,
+                    pluginData: resolution.pluginData,
+                    sideEffects: resolution.sideEffects,
+                    suffix: resolution.suffix,
+                    warnings: resolution.warnings,
+                    watchDirs: resolution.watchDirs,
+                    watchFiles: resolution.watchFiles
+                };
+            });
+        }
+    };
+}
+async function bundleEffectEntryForNode(options) {
+    await (0, external_esbuild_namespaceObject.build)({
+        absWorkingDir: options.appDir,
+        allowOverwrite: true,
+        bundle: true,
+        entryPoints: [
+            options.entryPath
+        ],
+        format: options.format,
+        logLevel: 'silent',
+        outfile: options.entryPath,
+        platform: 'node',
+        plugins: [
+            externalizeInstalledDependencies(),
+            preserveSourceModuleSemantics()
+        ],
+        target: 'node20'
+    });
+}
+function isWatchableInput(filename) {
+    return !filename.includes(`${external_node_path_default().sep}node_modules${external_node_path_default().sep}`) && (SOURCE_LOADERS.has(external_node_path_default().extname(filename).toLowerCase()) || '.json' === external_node_path_default().extname(filename).toLowerCase());
+}
+function normalizeImportedModule(module) {
+    if (!module || 'object' != typeof module) return module;
+    const namespace = module;
+    const commonJsModule = namespace.default;
+    if (1 === Object.keys(namespace).length && null !== commonJsModule && 'object' == typeof commonJsModule && true === commonJsModule.__esModule) return commonJsModule;
+    return module;
+}
+async function loadEffectSourceModule(options) {
+    const resourcePath = external_node_path_default().resolve(options.resourcePath);
+    const appDir = external_node_path_default().resolve(options.appDir ?? external_node_path_default().dirname(resourcePath));
+    const tsconfigPath = external_node_path_default().join(appDir, 'tsconfig.json');
+    const cacheDirectory = external_node_path_default().join(appDir, 'node_modules', '.cache', 'modern-js', 'effect-source-loader');
+    const outputName = external_node_crypto_default().createHash('sha256').update(resourcePath).digest('hex').slice(0, 24);
+    const outputPath = external_node_path_default().join(cacheDirectory, `${outputName}.mjs`);
+    await external_node_fs_default().promises.mkdir(cacheDirectory, {
+        recursive: true
+    });
+    const result = await (0, external_esbuild_namespaceObject.build)({
+        absWorkingDir: appDir,
+        banner: {
+            js: `import { createRequire as __modernCreateEffectRequire } from 'node:module'; const require = __modernCreateEffectRequire(${JSON.stringify((0, external_node_url_namespaceObject.pathToFileURL)(resourcePath).href)});`
+        },
+        bundle: true,
+        entryPoints: [
+            resourcePath
+        ],
+        format: 'esm',
+        jsx: 'automatic',
+        logLevel: 'silent',
+        metafile: true,
+        outfile: outputPath,
+        platform: 'node',
+        plugins: [
+            externalizeInstalledDependencies(),
+            preserveSourceModuleSemantics()
+        ],
+        sourcemap: 'inline',
+        target: 'node20',
+        tsconfig: external_node_fs_default().existsSync(tsconfigPath) ? tsconfigPath : void 0
+    });
+    for (const input of Object.keys(result.metafile.inputs)){
+        const dependency = external_node_path_default().isAbsolute(input) ? external_node_path_default().normalize(input) : external_node_path_default().resolve(appDir, input);
+        if (isWatchableInput(dependency)) options.onDependency?.(dependency);
+    }
+    const output = await external_node_fs_default().promises.readFile(outputPath);
+    const revision = external_node_crypto_default().createHash('sha256').update(output).digest('hex');
+    return normalizeImportedModule(await dynamicImport(`${(0, external_node_url_namespaceObject.pathToFileURL)(outputPath).href}?v=${revision}`));
+}
+exports.bundleEffectEntryForNode = __webpack_exports__.bundleEffectEntryForNode;
+exports.loadEffectSourceModule = __webpack_exports__.loadEffectSourceModule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "bundleEffectEntryForNode",
+    "loadEffectSourceModule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/cli/compress.mjs

@@ -0,0 +1,14 @@
+import { normalizePrefixList } from "./prefix.mjs";
+const createCompressConfig = (devServer, prefix)=>{
+    if (!devServer || 'object' != typeof devServer || Array.isArray(devServer)) return;
+    const { compress } = devServer;
+    if (void 0 === compress || true === compress) {
+        const prefixes = normalizePrefixList(prefix);
+        return {
+            filter: (req)=>!prefixes.some((item)=>req.url?.includes(item))
+        };
+    }
+    if (false === compress) return false;
+    return compress;
+};
+export { createCompressConfig };

package/dist/esm/cli/generator.mjs

@@ -0,0 +1,133 @@
+import { ApiRouter } from "@modern-js/bff-core";
+import { compile } from "@modern-js/server-utils";
+import { API_DIR, SHARED_DIR, fs, resolveServerTsconfig } from "@modern-js/utils";
+import path from "path";
+import clientGenerator from "../utils/clientGenerator.mjs";
+import { bundleEffectEntryForNode } from "../utils/effectSourceLoader.mjs";
+import pluginGenerator from "../utils/pluginGenerator.mjs";
+import runtimeGenerator from "../utils/runtimeGenerator.mjs";
+import { getPrimaryPrefix } from "./prefix.mjs";
+import { serializeServerGlobalVars, transformServerGlobalVars } from "./serverGlobalVars.mjs";
+const RUNTIME_CREATE_REQUEST = '@modern-js/plugin-bff/client';
+const effectEntryExtensions = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+function resolveEffectSourceEntry(appDirectory, apiDirectory, configuredEntry) {
+    const entry = configuredEntry ? path.isAbsolute(configuredEntry) ? configuredEntry : path.resolve(appDirectory, configuredEntry) : path.resolve(apiDirectory, 'index');
+    return path.extname(entry) ? entry : effectEntryExtensions.map((extension)=>`${entry}${extension}`).find((candidate)=>fs.existsSync(candidate));
+}
+function resolveBuiltEffectEntry(appDirectory, distDirectory, sourceEntry) {
+    if (!sourceEntry) return;
+    const relativeEntry = path.relative(appDirectory, sourceEntry);
+    if ('..' === relativeEntry || relativeEntry.startsWith(`..${path.sep}`)) throw new Error(`Effect BFF entry must be inside the application directory: ${sourceEntry}`);
+    const builtEntry = path.resolve(distDirectory, relativeEntry).replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js');
+    return fs.existsSync(builtEntry) ? builtEntry : void 0;
+}
+const createBffGenerator = (api)=>{
+    const compileApi = async ()=>{
+        const { appDirectory, distDirectory, apiDirectory, bffRuntimeFramework, 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 = resolveServerTsconfig(appDirectory, modernConfig?.server?.tsconfigPath);
+        const sourceDirs = [];
+        if (await fs.pathExists(apiDir)) sourceDirs.push(apiDir);
+        if (await fs.pathExists(sharedDir)) sourceDirs.push(sharedDir);
+        const { alias, globalVars } = modernConfig.source;
+        const { alias: resolveAlias } = modernConfig.resolve;
+        if (sourceDirs.length > 0) {
+            const combinedAlias = [].concat(alias ?? []).concat(resolveAlias ?? []);
+            const serializedGlobalVars = serializeServerGlobalVars(globalVars);
+            await compile(appDirectory, {
+                alias: combinedAlias
+            }, {
+                sourceDirs,
+                distDir,
+                tsconfigPath,
+                moduleType,
+                throwErrorInsteadOfExit: true
+            });
+            await transformServerGlobalVars(sourceDirs.map((sourceDir)=>path.resolve(distDir, path.relative(appDirectory, sourceDir))), serializedGlobalVars);
+            if ('effect' === bffRuntimeFramework) {
+                const sourceEntry = resolveEffectSourceEntry(appDirectory, apiDir, modernConfig.bff?.effect?.entry);
+                const builtEntry = resolveBuiltEffectEntry(appDirectory, distDir, sourceEntry);
+                if (!builtEntry) throw new Error(`Effect BFF entry was not emitted into ${distDir}: ${sourceEntry ?? path.resolve(apiDir, 'index')}`);
+                await bundleEffectEntryForNode({
+                    appDir: appDirectory,
+                    entryPath: builtEntry,
+                    format: 'module' === moduleType ? 'esm' : 'cjs'
+                });
+            }
+        }
+    };
+    const generate = async ()=>{
+        const { appDirectory, apiDirectory, lambdaDirectory, port, bffRuntimeFramework } = api.getAppContext();
+        const modernConfig = api.getNormalizedConfig();
+        const relativeDistPath = modernConfig?.output?.distPath?.root || 'dist';
+        const { bff } = modernConfig || {};
+        const prefix = getPrimaryPrefix(bff?.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,
+            runtimeFramework: 'hono' === bffRuntimeFramework ? 'hono' : 'effect'
+        });
+        await clientGenerator({
+            prefix,
+            appDir: appDirectory,
+            apiDir: apiDirectory,
+            lambdaDir,
+            existLambda,
+            port,
+            requestCreator: bff?.requestCreator,
+            httpMethodDecider,
+            relativeDistPath,
+            relativeApiPath,
+            bffRuntimeFramework,
+            effectEntry: bff?.effect?.entry,
+            effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch
+        });
+        await runtimeGenerator({
+            runtime,
+            appDirectory,
+            relativeDistPath
+        });
+    };
+    const handleCrossProjectInvocation = async (isBuild = false)=>{
+        const { bff } = api.getNormalizedConfig();
+        if (bff?.crossProject) {
+            if (!isBuild) await compileApi();
+            await generate();
+        }
+    };
+    return {
+        compileApi,
+        generate,
+        handleCrossProjectInvocation
+    };
+};
+export { createBffGenerator };

package/dist/esm/cli/prefix.mjs

@@ -0,0 +1,9 @@
+import { DEFAULT_API_PREFIX } from "@modern-js/utils";
+const normalizePrefixList = (prefix)=>{
+    if (Array.isArray(prefix)) return prefix.filter(Boolean);
+    return [
+        prefix || DEFAULT_API_PREFIX
+    ];
+};
+const getPrimaryPrefix = (prefix)=>normalizePrefixList(prefix)[0] || DEFAULT_API_PREFIX;
+export { getPrimaryPrefix, normalizePrefixList };

package/dist/esm/cli/serverGlobalVars.mjs

@@ -0,0 +1,76 @@
+import { applyOptionsChain, fs } from "@modern-js/utils";
+import { transform } from "@swc/core";
+import path from "path";
+const RELEASE_IDENTITY_GLOBAL_NAMES = [
+    'ULTRAMODERN_BUILD_MARKER',
+    'ULTRAMODERN_SOURCE_REVISION',
+    'ULTRAMODERN_RELEASE_VERSION'
+];
+const collectJavaScriptFiles = async (directory)=>{
+    const entries = await fs.readdir(directory, {
+        withFileTypes: true
+    });
+    const nested = await Promise.all(entries.map(async (entry)=>{
+        const absolutePath = path.join(directory, entry.name);
+        if (entry.isDirectory()) return collectJavaScriptFiles(absolutePath);
+        return /\.(?:c|m)?js$/u.test(entry.name) ? [
+            absolutePath
+        ] : [];
+    }));
+    return nested.flat();
+};
+const serializeServerGlobalVars = (options)=>{
+    const globalVars = applyOptionsChain({}, options, {
+        env: 'server',
+        target: 'node'
+    });
+    return Object.fromEntries(Object.entries(globalVars).map(([key, value])=>{
+        let serialized;
+        try {
+            serialized = JSON.stringify(value);
+        } catch (error) {
+            throw new Error(`source.globalVars["${key}"] cannot be serialized exactly for BFF compilation.`, {
+                cause: error
+            });
+        }
+        if (void 0 === serialized) throw new Error(`source.globalVars["${key}"] cannot be serialized exactly for BFF compilation.`);
+        return [
+            key,
+            serialized
+        ];
+    }));
+};
+const transformServerGlobalVars = async (outputDirectories, globalVars)=>{
+    if (0 === Object.keys(globalVars).length) return;
+    const existingDirectories = (await Promise.all(outputDirectories.map(async (directory)=>await fs.pathExists(directory) ? directory : void 0))).filter((directory)=>Boolean(directory));
+    const files = (await Promise.all(existingDirectories.map(collectJavaScriptFiles))).flat();
+    const releaseIdentityBanner = RELEASE_IDENTITY_GLOBAL_NAMES.every((name)=>Object.hasOwn(globalVars, name)) ? `${RELEASE_IDENTITY_GLOBAL_NAMES.map((name)=>`void ${globalVars[name]};`).join('')}\n` : '';
+    await Promise.all(files.map(async (filename)=>{
+        const source = await fs.readFile(filename, 'utf8');
+        const sourceMapFilename = `${filename}.map`;
+        const sourceMapExists = await fs.pathExists(sourceMapFilename);
+        const inputSourceMap = sourceMapExists ? await fs.readFile(sourceMapFilename, 'utf8') : void 0;
+        const result = await transform(`${releaseIdentityBanner}${source}`, {
+            filename,
+            inputSourceMap,
+            sourceMaps: sourceMapExists,
+            jsc: {
+                parser: {
+                    syntax: "ecmascript"
+                },
+                preserveAllComments: true,
+                target: 'es2022',
+                transform: {
+                    optimizer: {
+                        globals: {
+                            vars: globalVars
+                        }
+                    }
+                }
+            }
+        });
+        await fs.writeFile(filename, result.code);
+        if (sourceMapExists && result.map) await fs.writeFile(sourceMapFilename, result.map);
+    }));
+};
+export { serializeServerGlobalVars, transformServerGlobalVars };

package/dist/esm/cli/watch.mjs

@@ -0,0 +1,13 @@
+const WATCHABLE_EXTENSIONS = [
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mts',
+    '.cts',
+    '.mjs',
+    '.cjs',
+    '.json'
+];
+const isWatchableBffFile = (filename)=>WATCHABLE_EXTENSIONS.some((ext)=>filename.endsWith(ext));
+export { isWatchableBffFile };

package/dist/esm/cli.mjs

@@ -1,30 +1,10 @@
 import { ApiRouter } from "@modern-js/bff-core";
-import { compile } from "@modern-js/server-utils";
-import { API_DIR, DEFAULT_API_PREFIX, SHARED_DIR, fs, normalizeOutputPath, resolveServerTsconfig } from "@modern-js/utils";
+import { normalizeOutputPath } from "@modern-js/utils";
 import path from "path";
-import clientGenerator from "./utils/clientGenerator.mjs";
-import pluginGenerator from "./utils/pluginGenerator.mjs";
-import runtimeGenerator from "./utils/runtimeGenerator.mjs";
-const RUNTIME_CREATE_REQUEST = '@modern-js/plugin-bff/client';
-const WATCHABLE_EXTENSIONS = [
-    '.ts',
-    '.tsx',
-    '.js',
-    '.jsx',
-    '.mts',
-    '.cts',
-    '.mjs',
-    '.cjs',
-    '.json'
-];
-const isWatchableBffFile = (filename)=>WATCHABLE_EXTENSIONS.some((ext)=>filename.endsWith(ext));
-const normalizePrefixList = (prefix)=>{
-    if (Array.isArray(prefix)) return prefix.filter(Boolean);
-    return [
-        prefix || DEFAULT_API_PREFIX
-    ];
-};
-const getPrimaryPrefix = (prefix)=>normalizePrefixList(prefix)[0] || DEFAULT_API_PREFIX;
+import { createCompressConfig } from "./cli/compress.mjs";
+import { createBffGenerator } from "./cli/generator.mjs";
+import { getPrimaryPrefix } from "./cli/prefix.mjs";
+import { isWatchableBffFile } from "./cli/watch.mjs";
 const bffPlugin = ()=>({
         name: '@modern-js/plugin-bff',
         setup: (api)=>{
@@ -36,106 +16,14 @@ const bffPlugin = ()=>({
                     bffRuntimeFramework: 'hono' === userRuntimeFramework ? 'hono' : 'effect'
                 });
             }
-            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 = resolveServerTsconfig(appDirectory, modernConfig?.server?.tsconfigPath);
-                const sourceDirs = [];
-                if (await fs.pathExists(apiDir)) sourceDirs.push(apiDir);
-                if (await fs.pathExists(sharedDir)) sourceDirs.push(sharedDir);
-                const { alias } = modernConfig.source;
-                const { alias: resolveAlias } = modernConfig.resolve;
-                if (sourceDirs.length > 0) {
-                    const combinedAlias = [].concat(alias ?? []).concat(resolveAlias ?? []);
-                    await compile(appDirectory, {
-                        alias: combinedAlias
-                    }, {
-                        sourceDirs,
-                        distDir,
-                        tsconfigPath,
-                        moduleType,
-                        throwErrorInsteadOfExit: true
-                    });
-                }
-            };
-            const generator = async ()=>{
-                const { appDirectory, apiDirectory, lambdaDirectory, port, bffRuntimeFramework } = api.getAppContext();
-                const modernConfig = api.getNormalizedConfig();
-                const relativeDistPath = modernConfig?.output?.distPath?.root || 'dist';
-                const { bff } = modernConfig || {};
-                const prefix = getPrimaryPrefix(bff?.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,
-                    runtimeFramework: 'hono' === bffRuntimeFramework ? 'hono' : 'effect'
-                });
-                await clientGenerator({
-                    prefix,
-                    appDir: appDirectory,
-                    apiDir: apiDirectory,
-                    lambdaDir,
-                    existLambda,
-                    port,
-                    requestCreator: bff?.requestCreator,
-                    httpMethodDecider,
-                    relativeDistPath,
-                    relativeApiPath,
-                    bffRuntimeFramework,
-                    effectEntry: bff?.effect?.entry,
-                    effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch
-                });
-                await runtimeGenerator({
-                    runtime,
-                    appDirectory,
-                    relativeDistPath
-                });
-            };
-            const handleCrossProjectInvocation = async (isBuild = false)=>{
-                const { bff } = api.getNormalizedConfig();
-                if (bff?.crossProject) {
-                    if (!isBuild) await compileApi();
-                    await generator();
-                }
-            };
+            const { compileApi, handleCrossProjectInvocation } = createBffGenerator(api);
             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) {
-                    const prefixes = normalizePrefixList(prefix);
-                    return {
-                        filter: (req)=>!prefixes.some((item)=>req.url?.includes(item))
-                    };
-                }
-                if (false === compress) return false;
-                return compress;
-            };
             api.config(async ()=>{
                 const devServer = api.getConfig()?.tools?.devServer;
-                const prefix = api.getConfig()?.bff?.prefix || DEFAULT_API_PREFIX;
+                const prefix = api.getConfig()?.bff?.prefix;
                 const compress = createCompressConfig(devServer, prefix);
                 return {
                     tools: {
@@ -240,6 +128,4 @@ const bffPlugin = ()=>({
             });
         }
     });
-const cli = bffPlugin;
-export default cli;
 export { bffPlugin };