@bleedingdev/modern-js-plugin-bff 3.2.0-ultramodern.0

package/dist/esm/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/server.mjs

@@ -0,0 +1,135 @@
+import { ApiRouter } from "@modern-js/bff-core";
+import { API_DIR, isFunction, isWebOnly } from "@modern-js/utils";
+import path from "path";
+import { EffectAdapter } from "./runtime/effect/adapter.mjs";
+import { HonoAdapter } from "./runtime/hono/adapter.mjs";
+const RUNTIME_ADAPTER_FACTORIES = {
+    hono: [
+        (api)=>new HonoAdapter(api)
+    ],
+    effect: [
+        (api)=>new EffectAdapter(api)
+    ]
+};
+const normalizePrefixList = (prefix)=>{
+    if (Array.isArray(prefix)) return prefix.filter(Boolean);
+    return [
+        prefix || '/api'
+    ];
+};
+const getPrimaryPrefix = (prefix)=>normalizePrefixList(prefix)[0] || '/api';
+function resolveRuntimeFramework(runtimeFramework) {
+    return 'hono' === runtimeFramework ? 'hono' : 'effect';
+}
+class Storage {
+    reset() {
+        this.middlewares = [];
+    }
+    constructor(){
+        this.middlewares = [];
+    }
+}
+const server = ()=>({
+        name: '@modern-js/plugin-bff',
+        setup: (api)=>{
+            const storage = new Storage();
+            let apiRouter = null;
+            const appContext = api.getServerContext();
+            const runtimeFramework = resolveRuntimeFramework(appContext.bffRuntimeFramework);
+            const runtimeAdapters = RUNTIME_ADAPTER_FACTORIES[runtimeFramework].map((createAdapter)=>createAdapter(api));
+            api.onPrepare(async ()=>{
+                const appContext = api.getServerContext();
+                const { render } = appContext;
+                const { middlewares } = storage;
+                api.updateServerContext({
+                    ...appContext,
+                    apiMiddlewares: middlewares
+                });
+                const config = api.getServerConfig();
+                const prefixList = normalizePrefixList(config?.bff?.prefix);
+                const prefix = getPrimaryPrefix(config?.bff?.prefix);
+                const enableHandleWeb = config?.bff?.enableHandleWeb;
+                const httpMethodDecider = config?.bff?.httpMethodDecider;
+                const { distDirectory: pwd, middlewares: globalMiddlewares } = api.getServerContext();
+                const webOnly = await isWebOnly();
+                if ('hono' === runtimeFramework) {
+                    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 (!prefixList.some((item)=>c.req.path.startsWith(item)) && !enableHandleWeb) return next();
+                            return handler(c, next);
+                        },
+                        order: 'post',
+                        before: [
+                            'custom-server-hook',
+                            'custom-server-middleware',
+                            'render'
+                        ]
+                    });
+                }
+                await Promise.all(runtimeAdapters.map((adapter)=>adapter.registerMiddleware({
+                        prefix,
+                        enableHandleWeb
+                    })));
+            });
+            api.onReset(async ({ event })=>{
+                storage.reset();
+                const appContext = api.getServerContext();
+                const { middlewares } = storage;
+                api.updateServerContext({
+                    ...appContext,
+                    apiMiddlewares: middlewares
+                });
+                if ('file-change' === event.type) {
+                    if ('hono' === runtimeFramework && apiRouter) {
+                        const apiHandlerInfos = await apiRouter.getApiHandlers();
+                        const appContext = api.getServerContext();
+                        api.updateServerContext({
+                            ...appContext,
+                            apiHandlerInfos
+                        });
+                    }
+                    await Promise.all(runtimeAdapters.map((adapter)=>adapter.onApiHandlersUpdated?.()));
+                }
+            });
+            const prepareApiServer = async (input, next)=>{
+                if ('hono' !== runtimeFramework) return next(input);
+                const { pwd, prefix, httpMethodDecider } = input;
+                const defaultApiDirectory = path.resolve(pwd, API_DIR);
+                const appContext = api.getServerContext();
+                const apiDirectory = 'string' == typeof appContext.apiDirectory ? appContext.apiDirectory : defaultApiDirectory;
+                const lambdaDirectory = 'string' == typeof appContext.lambdaDirectory ? appContext.lambdaDirectory : void 0;
+                apiRouter = new ApiRouter({
+                    appDir: pwd,
+                    apiDir: apiDirectory,
+                    lambdaDir: lambdaDirectory,
+                    prefix,
+                    httpMethodDecider
+                });
+                const apiHandlerInfos = await apiRouter.getApiHandlers();
+                api.updateServerContext({
+                    ...appContext,
+                    apiRouter,
+                    apiHandlerInfos
+                });
+                return next(input);
+            };
+            api.prepareApiServer(prepareApiServer);
+        }
+    });
+export default server;

package/dist/esm/utils/clientGenerator.mjs

@@ -0,0 +1,293 @@
+import { generateClient } from "@modern-js/bff-core";
+import { fs, logger } from "@modern-js/utils";
+import path from "path";
+import { generateEffectClientCode, renderEffectClientDeclaration, resolveEffectEntryFile } from "./effectClientGenerator.mjs";
+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 GENERATED_RUNTIME_DIRS = [
+    CLIENT_DIR,
+    PLUGIN_DIR,
+    RUNTIME_DIR
+];
+const toPosixPath = (p)=>p.replace(/\\/g, '/');
+const posixJoin = (...args)=>toPosixPath(path.join(...args));
+function getPackageName(appDirectory) {
+    try {
+        const packageJsonPath = path.resolve(appDirectory, './package.json');
+        const packageJson = fs.readJSONSync(packageJsonPath);
+        return packageJson.name;
+    } catch  {
+        return;
+    }
+}
+function createFileDetails(options) {
+    const { appDirectory, baseDirectory, resourcePath, source, relativeDistPath } = options;
+    const relativePath = path.relative(baseDirectory, resourcePath);
+    const parsedPath = path.parse(relativePath);
+    const targetDir = posixJoin(`./${relativeDistPath}/${CLIENT_DIR}`, parsedPath.dir, `${parsedPath.name}.js`);
+    const absTargetDir = path.resolve(targetDir);
+    const relativePathFromAppDirectory = path.relative(appDirectory, path.dirname(resourcePath));
+    const typesFilePath = posixJoin(`./${relativeDistPath}`, relativePathFromAppDirectory, `${parsedPath.name}.d.ts`);
+    return {
+        resourcePath,
+        source,
+        targetDir,
+        name: parsedPath.name,
+        absTargetDir,
+        relativeTargetDistDir: `./${typesFilePath}`,
+        exportKey: toPosixPath(path.join(parsedPath.dir, parsedPath.name))
+    };
+}
+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');
+                filesList.push(createFileDetails({
+                    appDirectory,
+                    baseDirectory: directory,
+                    resourcePath,
+                    source,
+                    relativeDistPath
+                }));
+            }
+        }
+    }
+    await readFiles(directory);
+    return filesList;
+}
+function mergePackageJson(packageJson, files, typesVersion, exports, relativeDistPath) {
+    const distPrefix = toPosixPath(`./${relativeDistPath}/`);
+    const generatedPrefixes = GENERATED_RUNTIME_DIRS.map((dir)=>toPosixPath(`${distPrefix}${dir}/`));
+    const isManagedExportEntry = (value)=>{
+        if (!value) return false;
+        const values = [
+            value.import,
+            value.require,
+            value.types
+        ].filter(Boolean);
+        return values.every((entry)=>generatedPrefixes.some((prefix)=>entry.startsWith(prefix)));
+    };
+    const isManagedTypeEntry = (value)=>Array.isArray(value) && value.length > 0 && value.every((entry)=>generatedPrefixes.some((prefix)=>entry.startsWith(prefix)));
+    const normalizedFiles = [
+        ...new Set(files.map((file)=>toPosixPath(file)))
+    ];
+    const currentFiles = packageJson.files || [];
+    packageJson.files = [
+        ...new Set([
+            ...currentFiles.map((file)=>toPosixPath(file)),
+            ...normalizedFiles
+        ])
+    ];
+    packageJson.typesVersions ??= {};
+    const typesVersions = packageJson.typesVersions;
+    const starTypes = typesVersions['*'] || {};
+    const generatedTypeEntries = typesVersion['*'] || {};
+    const generatedTypeKeys = new Set(Object.keys(generatedTypeEntries));
+    const typeConflicts = Object.entries(starTypes).filter(([key, value])=>{
+        if (!generatedTypeKeys.has(key) && !key.startsWith(TYPE_PREFIX)) return false;
+        const generatedValue = generatedTypeEntries[key];
+        if (generatedValue) return JSON.stringify(value) !== JSON.stringify(generatedValue) && !isManagedTypeEntry(value);
+        return !isManagedTypeEntry(value);
+    }).map(([key])=>key);
+    if (typeConflicts.length > 0) throw new Error(`[plugin-bff] package.json typesVersions conflict on keys: ${typeConflicts.sort().join(', ')}. Rename these keys or move them outside "${TYPE_PREFIX}" namespace.`);
+    Object.keys(starTypes).forEach((key)=>{
+        if (generatedTypeKeys.has(key) || key.startsWith(TYPE_PREFIX)) delete starTypes[key];
+    });
+    typesVersions['*'] = {
+        ...starTypes,
+        ...generatedTypeEntries
+    };
+    packageJson.exports ??= {};
+    const packageExports = packageJson.exports;
+    const generatedExportKeys = new Set(Object.keys(exports));
+    const exportConflicts = Object.entries(packageExports).filter(([key, value])=>{
+        if (!generatedExportKeys.has(key) && !key.startsWith(EXPORT_PREFIX)) return false;
+        const generatedValue = exports[key];
+        if (generatedValue) return JSON.stringify(value) !== JSON.stringify(generatedValue) && !isManagedExportEntry(value);
+        return !isManagedExportEntry(value);
+    }).map(([key])=>key);
+    if (exportConflicts.length > 0) throw new Error(`[plugin-bff] package.json exports conflict on keys: ${exportConflicts.sort().join(', ')}. Rename these exports or move them outside "${EXPORT_PREFIX}" namespace.`);
+    Object.keys(packageExports).forEach((key)=>{
+        if (generatedExportKeys.has(key) || key.startsWith(EXPORT_PREFIX)) delete packageExports[key];
+    });
+    Object.assign(packageExports, exports);
+}
+async function writeTargetFile(absTargetDir, content) {
+    await fs.mkdir(path.dirname(absTargetDir), {
+        recursive: true
+    });
+    await fs.writeFile(absTargetDir, content);
+}
+function getClientPackageName(appDirectory) {
+    const packageName = getPackageName(appDirectory) || path.basename(appDirectory);
+    if (packageName.startsWith('@') && packageName.includes('/')) {
+        const [scope, name] = packageName.split('/');
+        return `${scope}/${name}-bff-client`;
+    }
+    return `${packageName}-bff-client`;
+}
+async function writeClientModuleBoundary(appDirectory, relativeDistPath) {
+    await writeTargetFile(path.resolve(appDirectory, relativeDistPath, CLIENT_DIR, 'package.json'), `${JSON.stringify({
+        private: true,
+        name: getClientPackageName(appDirectory),
+        type: 'module'
+    }, null, 2)}\n`);
+}
+async function setPackage(files, appDirectory, relativeDistPath) {
+    const packagePath = path.resolve(appDirectory, './package.json');
+    const packageContent = await fs.readFile(packagePath, 'utf8');
+    const packageJson = JSON.parse(packageContent);
+    const sortedFiles = [
+        ...files
+    ].sort((a, b)=>a.exportKey.localeCompare(b.exportKey));
+    const addFiles = [
+        posixJoin(relativeDistPath, CLIENT_DIR, '**', '*'),
+        posixJoin(relativeDistPath, RUNTIME_DIR, '**', '*'),
+        posixJoin(relativeDistPath, PLUGIN_DIR, '**', '*')
+    ];
+    const typesVersions = {
+        '*': sortedFiles.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 = sortedFiles.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, relativeDistPath);
+    await fs.promises.writeFile(packagePath, JSON.stringify(packageJson, null, 2));
+}
+async function copyFiles(from, to) {
+    if (await fs.pathExists(from)) await fs.copy(toPosixPath(from), toPosixPath(to));
+}
+async function clientGenerator(draftOptions) {
+    const generatedClientDir = path.resolve(draftOptions.appDir, draftOptions.relativeDistPath, CLIENT_DIR);
+    await fs.remove(generatedClientDir);
+    const requestId = getPackageName(draftOptions.appDir) || process.env.npm_package_name;
+    const lambdaSourceList = draftOptions.existLambda ? await readDirectoryFiles(draftOptions.appDir, draftOptions.lambdaDir, draftOptions.relativeDistPath) : [];
+    const generatedSourceList = [
+        ...lambdaSourceList
+    ];
+    const getClitentCode = async (resourcePath, source)=>{
+        const warning = `The file ${resourcePath} is not allowed 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,
+            requestId
+        };
+        const { lambdaDir } = draftOptions;
+        if (!resourcePath.startsWith(lambdaDir)) return void logger.warn(warning);
+        const result = await generateClient(options);
+        return result;
+    };
+    try {
+        for (const source of lambdaSourceList){
+            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'));
+            }
+        }
+        if ('effect' === draftOptions.bffRuntimeFramework) {
+            const effectEntryFile = resolveEffectEntryFile({
+                appDir: draftOptions.appDir,
+                apiDir: draftOptions.apiDir,
+                effectEntry: draftOptions.effectEntry
+            });
+            if (effectEntryFile) {
+                const effectSource = await fs.readFile(effectEntryFile, 'utf8');
+                const effectFileDetails = createFileDetails({
+                    appDirectory: draftOptions.appDir,
+                    baseDirectory: draftOptions.apiDir,
+                    resourcePath: effectEntryFile,
+                    source: effectSource,
+                    relativeDistPath: draftOptions.relativeDistPath
+                });
+                const effectClientCode = await generateEffectClientCode({
+                    appDir: draftOptions.appDir,
+                    apiDir: draftOptions.apiDir,
+                    resourcePath: effectEntryFile,
+                    prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
+                    port: Number(draftOptions.port),
+                    target: 'bundle',
+                    requestCreator: draftOptions.requestCreator,
+                    httpMethodDecider: draftOptions.httpMethodDecider,
+                    dataPlatformBatch: draftOptions.effectDataPlatformBatch
+                });
+                if (effectClientCode) {
+                    const targetTypeFile = effectFileDetails.targetDir.replace(/\.js$/, '.d.ts');
+                    await writeTargetFile(effectFileDetails.absTargetDir, effectClientCode);
+                    await writeTargetFile(path.resolve(targetTypeFile), renderEffectClientDeclaration());
+                    generatedSourceList.push(effectFileDetails);
+                }
+            }
+        }
+        logger.info("Client bundle generate succeed");
+    } catch (error) {
+        logger.error(`Client bundle generate failed: ${error}`);
+    }
+    if (generatedSourceList.length > 0) await writeClientModuleBoundary(draftOptions.appDir, draftOptions.relativeDistPath);
+    await setPackage(generatedSourceList, draftOptions.appDir, draftOptions.relativeDistPath);
+}
+const utils_clientGenerator = clientGenerator;
+export default utils_clientGenerator;
+export { copyFiles, readDirectoryFiles };

package/dist/esm/utils/createHonoRoutes.mjs

@@ -0,0 +1,92 @@
+import { HttpMetadata, ResponseMetaType, ValidationError, isWithMetaHandler } from "@modern-js/bff-core";
+import { parse } from "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 default utils_createHonoRoutes;
+export { createHonoHandler };

package/dist/esm/utils/crossProjectApiPlugin.mjs

@@ -0,0 +1,54 @@
+import path from "path";
+const PACKAGE_NAME = '{packageName}';
+const PREFIX = '{prefix}';
+const API_DIR = '{apiDirectory}';
+const LAMBDA_DIR = '{lambdaDirectory}';
+const DIST_DIR = '{distDirectory}';
+const RUNTIME_FRAMEWORK = '{runtimeFramework}';
+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,
+                    bffRuntimeFramework: RUNTIME_FRAMEWORK
+                });
+                const config = api.getConfig();
+                const configuredPrefix = config?.bff?.prefix;
+                if (configuredPrefix) {
+                    const isSamePrefix = Array.isArray(configuredPrefix) ? 1 === configuredPrefix.length && configuredPrefix[0] === PREFIX : configuredPrefix === PREFIX;
+                    if (!isSamePrefix) throw new Error(`[${PACKAGE_NAME}] Invalid bff.prefix for cross-project BFF. Detected "${configuredPrefix}", expected "${PREFIX}". Remove bff.prefix from the consumer app, or set it exactly to "${PREFIX}".`);
+                }
+                const configuredRuntimeFramework = config?.bff?.runtimeFramework;
+                if (configuredRuntimeFramework && configuredRuntimeFramework !== RUNTIME_FRAMEWORK) throw new Error(`[${PACKAGE_NAME}] Runtime framework mismatch for cross-project BFF. Detected "${configuredRuntimeFramework}", but producer SDK requires "${RUNTIME_FRAMEWORK}".`);
+                resolvedConfig.bff.prefix = PREFIX;
+                resolvedConfig.bff.runtimeFramework = RUNTIME_FRAMEWORK;
+                resolvedConfig.bff.isCrossProjectServer = true;
+                resolvedConfig.bff.requestId = resolvedConfig.bff.requestId || config?.bff?.requestId || PACKAGE_NAME || 'default';
+                resolvedConfig.bff.crossProjectPolicy = {
+                    ...resolvedConfig.bff.crossProjectPolicy || {},
+                    enabled: resolvedConfig.bff.crossProjectPolicy?.enabled ?? true,
+                    requireEnvelope: resolvedConfig.bff.crossProjectPolicy?.requireEnvelope ?? true,
+                    requireOperationContext: resolvedConfig.bff.crossProjectPolicy?.requireOperationContext ?? true,
+                    requireOperationContextDetails: resolvedConfig.bff.crossProjectPolicy?.requireOperationContextDetails ?? true,
+                    requireOperationSchemaHash: resolvedConfig.bff.crossProjectPolicy?.requireOperationSchemaHash ?? true,
+                    requireOperationVersion: resolvedConfig.bff.crossProjectPolicy?.requireOperationVersion ?? true,
+                    allowUnknownOperations: resolvedConfig.bff.crossProjectPolicy?.allowUnknownOperations ?? false
+                };
+                return resolvedConfig;
+            });
+        }
+    });
+const utils_crossProjectApiPlugin = crossProjectApiPlugin;
+export default utils_crossProjectApiPlugin;
+export { API_DIR, DIST_DIR, LAMBDA_DIR, PACKAGE_NAME, PREFIX, RUNTIME_FRAMEWORK, crossProjectApiPlugin };