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

package/dist/cjs/utils/clientGenerator.js

@@ -0,0 +1,342 @@
+"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, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    copyFiles: ()=>copyFiles,
+    default: ()=>utils_clientGenerator,
+    readDirectoryFiles: ()=>readDirectoryFiles
+});
+const bff_core_namespaceObject = require("@modern-js/bff-core");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_effectClientGenerator_js_namespaceObject = require("./effectClientGenerator.js");
+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(external_path_default().join(...args));
+function getPackageName(appDirectory) {
+    try {
+        const packageJsonPath = external_path_default().resolve(appDirectory, './package.json');
+        const packageJson = utils_namespaceObject.fs.readJSONSync(packageJsonPath);
+        return packageJson.name;
+    } catch  {
+        return;
+    }
+}
+function createFileDetails(options) {
+    const { appDirectory, baseDirectory, resourcePath, source, relativeDistPath } = options;
+    const relativePath = external_path_default().relative(baseDirectory, resourcePath);
+    const parsedPath = external_path_default().parse(relativePath);
+    const targetDir = posixJoin(`./${relativeDistPath}/${CLIENT_DIR}`, parsedPath.dir, `${parsedPath.name}.js`);
+    const absTargetDir = external_path_default().resolve(targetDir);
+    const relativePathFromAppDirectory = external_path_default().relative(appDirectory, external_path_default().dirname(resourcePath));
+    const typesFilePath = posixJoin(`./${relativeDistPath}`, relativePathFromAppDirectory, `${parsedPath.name}.d.ts`);
+    return {
+        resourcePath,
+        source,
+        targetDir,
+        name: parsedPath.name,
+        absTargetDir,
+        relativeTargetDistDir: `./${typesFilePath}`,
+        exportKey: toPosixPath(external_path_default().join(parsedPath.dir, parsedPath.name))
+    };
+}
+async function readDirectoryFiles(appDirectory, directory, relativeDistPath) {
+    const filesList = [];
+    async function readFiles(currentPath) {
+        const entries = await utils_namespaceObject.fs.readdir(currentPath, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if ('_app.ts' === entry.name) continue;
+            const resourcePath = external_path_default().join(currentPath, entry.name);
+            if (entry.isDirectory()) await readFiles(resourcePath);
+            else {
+                const source = await utils_namespaceObject.fs.readFile(resourcePath, 'utf8');
+                filesList.push(createFileDetails({
+                    appDirectory,
+                    baseDirectory: directory,
+                    resourcePath,
+                    source,
+                    relativeDistPath
+                }));
+            }
+        }
+    }
+    await readFiles(directory);
+    return filesList;
+}
+function mergePackageJson(packageJson, files, typesVersion, exports1, 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(exports1));
+    const exportConflicts = Object.entries(packageExports).filter(([key, value])=>{
+        if (!generatedExportKeys.has(key) && !key.startsWith(EXPORT_PREFIX)) return false;
+        const generatedValue = exports1[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, exports1);
+}
+async function writeTargetFile(absTargetDir, content) {
+    await utils_namespaceObject.fs.mkdir(external_path_default().dirname(absTargetDir), {
+        recursive: true
+    });
+    await utils_namespaceObject.fs.writeFile(absTargetDir, content);
+}
+function getClientPackageName(appDirectory) {
+    const packageName = getPackageName(appDirectory) || external_path_default().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(external_path_default().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 = external_path_default().resolve(appDirectory, './package.json');
+    const packageContent = await utils_namespaceObject.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 exports1 = 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, exports1, relativeDistPath);
+    await utils_namespaceObject.fs.promises.writeFile(packagePath, JSON.stringify(packageJson, null, 2));
+}
+async function copyFiles(from, to) {
+    if (await utils_namespaceObject.fs.pathExists(from)) await utils_namespaceObject.fs.copy(toPosixPath(from), toPosixPath(to));
+}
+async function clientGenerator(draftOptions) {
+    const generatedClientDir = external_path_default().resolve(draftOptions.appDir, draftOptions.relativeDistPath, CLIENT_DIR);
+    await utils_namespaceObject.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 utils_namespaceObject.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 utils_namespaceObject.logger.warn(warning);
+        const result = await (0, bff_core_namespaceObject.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 = (0, external_effectClientGenerator_js_namespaceObject.resolveEffectEntryFile)({
+                appDir: draftOptions.appDir,
+                apiDir: draftOptions.apiDir,
+                effectEntry: draftOptions.effectEntry
+            });
+            if (effectEntryFile) {
+                const effectSource = await utils_namespaceObject.fs.readFile(effectEntryFile, 'utf8');
+                const effectFileDetails = createFileDetails({
+                    appDirectory: draftOptions.appDir,
+                    baseDirectory: draftOptions.apiDir,
+                    resourcePath: effectEntryFile,
+                    source: effectSource,
+                    relativeDistPath: draftOptions.relativeDistPath
+                });
+                const effectClientCode = await (0, external_effectClientGenerator_js_namespaceObject.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(external_path_default().resolve(targetTypeFile), (0, external_effectClientGenerator_js_namespaceObject.renderEffectClientDeclaration)());
+                    generatedSourceList.push(effectFileDetails);
+                }
+            }
+        }
+        utils_namespaceObject.logger.info("Client bundle generate succeed");
+    } catch (error) {
+        utils_namespaceObject.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;
+exports.copyFiles = __webpack_exports__.copyFiles;
+exports["default"] = __webpack_exports__["default"];
+exports.readDirectoryFiles = __webpack_exports__.readDirectoryFiles;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "copyFiles",
+    "default",
+    "readDirectoryFiles"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/createHonoRoutes.js

@@ -0,0 +1,138 @@
+"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, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    createHonoHandler: ()=>createHonoHandler,
+    default: ()=>utils_createHonoRoutes
+});
+const bff_core_namespaceObject = require("@modern-js/bff-core");
+const external_qs_namespaceObject = require("qs");
+const external_type_is_namespaceObject = require("type-is");
+var external_type_is_default = /*#__PURE__*/ __webpack_require__.n(external_type_is_namespaceObject);
+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(bff_core_namespaceObject.HttpMetadata.Response, handler);
+    if (Array.isArray(responseMeta)) for (const meta of responseMeta)switch(meta.type){
+        case bff_core_namespaceObject.ResponseMetaType.Headers:
+            for (const [key, value] of Object.entries(meta.value))c.header(key, value);
+            break;
+        case bff_core_namespaceObject.ResponseMetaType.Redirect:
+            return c.redirect(meta.value);
+        case bff_core_namespaceObject.ResponseMetaType.StatusCode:
+            c.status(meta.value);
+            break;
+        default:
+            break;
+    }
+    return null;
+};
+const createHonoHandler = (handler)=>async (c)=>{
+        const input = await getHonoInput(c);
+        if ((0, bff_core_namespaceObject.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 bff_core_namespaceObject.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: (0, external_qs_namespaceObject.parse)(c.req.query()),
+        headers: c.req.header(),
+        cookies: c.req.header('cookie')
+    };
+    try {
+        const contentType = c.req.header('content-type') || '';
+        if (external_type_is_default().is(contentType, [
+            'application/json'
+        ])) draft.data = await c.req.json();
+        else if (external_type_is_default().is(contentType, [
+            'multipart/form-data'
+        ])) draft.formData = await c.req.parseBody();
+        else if (external_type_is_default().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;
+exports.createHonoHandler = __webpack_exports__.createHonoHandler;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createHonoHandler",
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/crossProjectApiPlugin.js

@@ -0,0 +1,118 @@
+"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, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    API_DIR: ()=>API_DIR,
+    DIST_DIR: ()=>DIST_DIR,
+    LAMBDA_DIR: ()=>LAMBDA_DIR,
+    PACKAGE_NAME: ()=>PACKAGE_NAME,
+    PREFIX: ()=>PREFIX,
+    RUNTIME_FRAMEWORK: ()=>RUNTIME_FRAMEWORK,
+    crossProjectApiPlugin: ()=>crossProjectApiPlugin,
+    default: ()=>utils_crossProjectApiPlugin
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+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 = external_path_default().join(originAppDirectory, NODE_MODULES, PACKAGE_NAME);
+                const sdkDistPath = external_path_default().join(sdkPath, DIST_DIR);
+                const apiDirectory = external_path_default().join(sdkDistPath, API_DIR);
+                const lambdaDirectory = external_path_default().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;
+exports.API_DIR = __webpack_exports__.API_DIR;
+exports.DIST_DIR = __webpack_exports__.DIST_DIR;
+exports.LAMBDA_DIR = __webpack_exports__.LAMBDA_DIR;
+exports.PACKAGE_NAME = __webpack_exports__.PACKAGE_NAME;
+exports.PREFIX = __webpack_exports__.PREFIX;
+exports.RUNTIME_FRAMEWORK = __webpack_exports__.RUNTIME_FRAMEWORK;
+exports.crossProjectApiPlugin = __webpack_exports__.crossProjectApiPlugin;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "API_DIR",
+    "DIST_DIR",
+    "LAMBDA_DIR",
+    "PACKAGE_NAME",
+    "PREFIX",
+    "RUNTIME_FRAMEWORK",
+    "crossProjectApiPlugin",
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});