@bleedingdev/modern-js-plugin-bff 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/dist/cjs/utils/client-generator/generate.js

@@ -48,15 +48,14 @@ const external_files_js_namespaceObject = require("./files.js");
 const external_package_json_js_namespaceObject = require("./package-json.js");
 const external_type_facade_js_namespaceObject = require("./type-facade.js");
 const external_write_package_js_namespaceObject = require("./write-package.js");
-async function clientGenerator(draftOptions) {
+async function clientGenerator(draftOptions, integration) {
     const generatedClientDir = external_path_default().resolve(draftOptions.appDir, draftOptions.relativeDistPath, external_files_js_namespaceObject.CLIENT_DIR);
     await utils_namespaceObject.fs.remove(generatedClientDir);
-    const requestId = (0, external_package_json_js_namespaceObject.getPackageName)(draftOptions.appDir) || process.env.npm_package_name;
+    const requestId = draftOptions.requestId || (0, external_package_json_js_namespaceObject.getPackageName)(draftOptions.appDir) || process.env.npm_package_name;
     const lambdaSourceList = draftOptions.existLambda ? await (0, external_files_js_namespaceObject.readDirectoryFiles)(draftOptions.appDir, draftOptions.lambdaDir, draftOptions.relativeDistPath, draftOptions.apiFiles) : [];
     const generatedSourceList = [
         ...lambdaSourceList
     ];
-    let generatedEffectClient = null;
     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);
@@ -71,6 +70,7 @@ async function clientGenerator(draftOptions) {
             target: 'bundle',
             httpMethodDecider: draftOptions.httpMethodDecider,
             requestCreator: draftOptions.requestCreator,
+            clientCodegenPlugin: draftOptions.clientCodegenPlugin,
             requestId
         };
         const { lambdaDir } = draftOptions;
@@ -79,9 +79,9 @@ async function clientGenerator(draftOptions) {
         return result;
     };
     const writeClientTypeFacade = async (source, clientCode)=>{
-        if (!await utils_namespaceObject.fs.pathExists(external_path_default().resolve(source.relativeTargetDistDir))) throw (0, external_type_facade_js_namespaceObject.createMissingClientDeclarationError)(source.resourcePath, source.relativeTargetDistDir);
-        const clientTypesFile = source.targetDir.replace(/\.js$/, '.d.ts');
-        await (0, external_files_js_namespaceObject.writeTargetFile)(external_path_default().resolve(clientTypesFile), (0, external_type_facade_js_namespaceObject.buildClientTypeFacade)(clientTypesFile, source.relativeTargetDistDir, external_type_facade_js_namespaceObject.DEFAULT_EXPORT_RE.test(clientCode), true));
+        if (!await utils_namespaceObject.fs.pathExists(external_path_default().resolve(draftOptions.appDir, source.relativeTargetDistDir))) throw (0, external_type_facade_js_namespaceObject.createMissingClientDeclarationError)(source.resourcePath, external_path_default().resolve(draftOptions.appDir, source.relativeTargetDistDir));
+        const clientTypesFile = source.absTargetDir.replace(/\.js$/, '.d.ts');
+        await (0, external_files_js_namespaceObject.writeTargetFile)(external_path_default().resolve(clientTypesFile), (0, external_type_facade_js_namespaceObject.buildClientTypeFacade)(clientTypesFile, external_path_default().resolve(draftOptions.appDir, source.relativeTargetDistDir), external_type_facade_js_namespaceObject.DEFAULT_EXPORT_RE.test(clientCode), true));
     };
     try {
         for (const source of lambdaSourceList){
@@ -91,50 +91,51 @@ async function clientGenerator(draftOptions) {
                 await writeClientTypeFacade(source, code.value);
             }
         }
-        if ('effect' === draftOptions.bffRuntimeFramework) {
-            const { generateEffectClient, resolveEffectEntryFile } = await import("@modern-js/plugin-bff-extensions/client-generator");
-            const effectEntryFile = resolveEffectEntryFile({
-                appDir: draftOptions.appDir,
-                apiDir: draftOptions.apiDir,
-                effectEntry: draftOptions.effectEntry
-            });
-            if (effectEntryFile) {
-                const effectSource = await utils_namespaceObject.fs.readFile(effectEntryFile, 'utf8');
-                const effectFileDetails = (0, external_files_js_namespaceObject.createFileDetails)({
-                    appDirectory: draftOptions.appDir,
-                    baseDirectory: draftOptions.apiDir,
-                    resourcePath: effectEntryFile,
-                    source: effectSource,
-                    relativeDistPath: draftOptions.relativeDistPath
-                });
-                generatedEffectClient = await generateEffectClient({
-                    appDir: draftOptions.appDir,
-                    apiDir: draftOptions.apiDir,
-                    resourcePath: effectEntryFile,
-                    prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
-                    port: Number(draftOptions.port),
-                    target: 'bundle',
-                    requestId: draftOptions.requestId,
-                    requestCreator: draftOptions.requestCreator,
-                    httpMethodDecider: draftOptions.httpMethodDecider,
-                    dataPlatformBatch: draftOptions.effectDataPlatformBatch
-                });
-                if (generatedEffectClient) {
-                    const targetTypeFile = effectFileDetails.targetDir.replace(/\.js$/, '.d.ts');
-                    await (0, external_files_js_namespaceObject.writeTargetFile)(effectFileDetails.absTargetDir, generatedEffectClient.code);
-                    await (0, external_files_js_namespaceObject.writeTargetFile)(external_path_default().resolve(targetTypeFile), generatedEffectClient.declaration);
-                    generatedSourceList.push(effectFileDetails);
-                }
-            }
-        }
         utils_namespaceObject.logger.info("Client bundle generate succeed");
     } catch (error) {
-        if ((0, external_type_facade_js_namespaceObject.isMissingClientDeclarationError)(error)) throw error;
+        if ((0, external_type_facade_js_namespaceObject.isMissingClientDeclarationError)(error) || error instanceof bff_core_namespaceObject.ClientCodegenError) throw error;
         utils_namespaceObject.logger.error(`Client bundle generate failed: ${error}`);
     }
+    let packageDependencies;
+    if (integration) {
+        const artifacts = await integration.modifyArtifacts({
+            generation: integration.generation,
+            additionalArtifacts: []
+        });
+        if (artifacts.generation !== integration.generation) throw new Error('BFF artifacts must preserve generation identity.');
+        const sourcePaths = new Set(generatedSourceList.map((file)=>external_path_default().resolve(file.resourcePath)));
+        const exportKeys = new Set(generatedSourceList.map((file)=>file.exportKey));
+        const outputPaths = new Set(generatedSourceList.map((file)=>external_path_default().resolve(file.absTargetDir)));
+        const additionalFiles = artifacts.additionalArtifacts.map((artifact)=>{
+            const relative = artifact.sourcePath;
+            const resourcePath = external_path_default().resolve(draftOptions.apiDir, relative);
+            if (!relative || external_path_default().isAbsolute(relative) || relative.includes('\\') || external_path_default().relative(draftOptions.apiDir, resourcePath).split(external_path_default().sep).includes('..') || external_path_default().relative(draftOptions.apiDir, resourcePath).split(external_path_default().sep).join('/') !== relative || !/\.[cm]?[jt]sx?$/.test(relative)) throw new Error(`Invalid BFF client artifact source path: ${relative}`);
+            const file = (0, external_files_js_namespaceObject.createFileDetails)({
+                appDirectory: draftOptions.appDir,
+                baseDirectory: draftOptions.apiDir,
+                resourcePath,
+                source: '',
+                relativeDistPath: draftOptions.relativeDistPath
+            });
+            if (sourcePaths.has(resourcePath) || exportKeys.has(file.exportKey) || outputPaths.has(external_path_default().resolve(file.absTargetDir))) throw new Error(`BFF client artifact collision: ${relative}`);
+            sourcePaths.add(resourcePath);
+            exportKeys.add(file.exportKey);
+            outputPaths.add(external_path_default().resolve(file.absTargetDir));
+            return {
+                file,
+                artifact
+            };
+        });
+        for (const { file, artifact } of additionalFiles){
+            await (0, external_files_js_namespaceObject.writeTargetFile)(file.absTargetDir, artifact.code);
+            await (0, external_files_js_namespaceObject.writeTargetFile)(file.absTargetDir.replace(/\.js$/, '.d.ts'), artifact.declaration);
+            generatedSourceList.push(file);
+        }
+        packageDependencies = await integration.beforePublish() || void 0;
+    }
     if (generatedSourceList.length > 0) await (0, external_write_package_js_namespaceObject.writeClientModuleBoundary)(draftOptions.appDir, draftOptions.relativeDistPath);
-    await (0, external_write_package_js_namespaceObject.setPackage)(generatedSourceList, draftOptions.appDir, draftOptions.relativeDistPath);
-    return generatedEffectClient;
+    await (0, external_write_package_js_namespaceObject.setPackage)(generatedSourceList, draftOptions.appDir, draftOptions.relativeDistPath, packageDependencies);
+    return null;
 }
 const generate = clientGenerator;
 exports.clientGenerator = __webpack_exports__.clientGenerator;

package/dist/cjs/utils/client-generator/package-json.js

@@ -90,7 +90,7 @@ function mergePackageJson(packageJson, files, typesVersion, exports1, relativeDi
     }).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 "${external_files_js_namespaceObject.TYPE_PREFIX}" namespace.`);
     Object.keys(starTypes).forEach((key)=>{
-        if (generatedTypeKeys.has(key) || key.startsWith(external_files_js_namespaceObject.TYPE_PREFIX)) delete starTypes[key];
+        if (generatedTypeKeys.has(key) || key.startsWith(external_files_js_namespaceObject.TYPE_PREFIX) || key === external_files_js_namespaceObject.RUNTIME_DIR && isManagedTypeEntry(starTypes[key])) delete starTypes[key];
     });
     typesVersions['*'] = {
         ...starTypes,
@@ -107,7 +107,7 @@ function mergePackageJson(packageJson, files, typesVersion, exports1, relativeDi
     }).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 "${external_files_js_namespaceObject.EXPORT_PREFIX}" namespace.`);
     Object.keys(packageExports).forEach((key)=>{
-        if (generatedExportKeys.has(key) || key.startsWith(external_files_js_namespaceObject.EXPORT_PREFIX)) delete packageExports[key];
+        if (generatedExportKeys.has(key) || key.startsWith(external_files_js_namespaceObject.EXPORT_PREFIX) || key === `./${external_files_js_namespaceObject.RUNTIME_DIR}` && isManagedExportEntry(packageExports[key])) delete packageExports[key];
     });
     Object.assign(packageExports, exports1);
 }

package/dist/cjs/utils/client-generator/write-package.js

@@ -52,10 +52,19 @@ async function writeClientModuleBoundary(appDirectory, relativeDistPath) {
         type: 'module'
     }, null, 2)}\n`);
 }
-async function setPackage(files, appDirectory, relativeDistPath) {
+async function setPackage(files, appDirectory, relativeDistPath, packageDependencies = {}) {
     const packagePath = external_path_default().resolve(appDirectory, './package.json');
     const packageContent = await utils_namespaceObject.fs.readFile(packagePath, 'utf8');
     const packageJson = JSON.parse(packageContent);
+    for (const [name, specifier] of Object.entries(packageDependencies)){
+        if (!name || 'string' != typeof specifier || !specifier.trim()) throw new Error(`Invalid BFF SDK dependency: ${name}`);
+        const existing = packageJson.dependencies?.[name];
+        if (void 0 !== existing && existing !== specifier) throw new Error(`package.json dependency conflict for ${name}: ${existing} versus ${specifier}`);
+    }
+    if (Object.keys(packageDependencies).length > 0) packageJson.dependencies = {
+        ...packageJson.dependencies,
+        ...packageDependencies
+    };
     const sortedFiles = [
         ...files
     ].sort((a, b)=>a.exportKey.localeCompare(b.exportKey));
@@ -112,6 +121,14 @@ async function setPackage(files, appDirectory, relativeDistPath) {
             types: (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/${external_files_js_namespaceObject.RUNTIME_DIR}/index.d.ts`)
         }
     });
+    if (0 === files.length) {
+        Reflect.deleteProperty(typesVersions['*'], `${external_files_js_namespaceObject.API_DIR}/*`);
+        Reflect.deleteProperty(exports1, `./${external_files_js_namespaceObject.API_DIR}/*`);
+    }
+    if (!utils_namespaceObject.fs.existsSync(external_path_default().resolve(appDirectory, relativeDistPath, external_files_js_namespaceObject.RUNTIME_DIR, 'index.js'))) {
+        Reflect.deleteProperty(typesVersions['*'], external_files_js_namespaceObject.RUNTIME_DIR);
+        Reflect.deleteProperty(exports1, `./${external_files_js_namespaceObject.RUNTIME_DIR}`);
+    }
     (0, external_package_json_js_namespaceObject.mergePackageJson)(packageJson, addFiles, typesVersions, exports1, relativeDistPath);
     await utils_namespaceObject.fs.promises.writeFile(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`);
 }

package/dist/cjs/utils/createHonoRoutes.js

@@ -90,7 +90,7 @@ const createHonoHandler = (handler)=>async (c)=>{
             }
             throw error;
         }
-        {
+        else {
             const routePath = c.req.routePath;
             const paramNames = routePath.match(/:\w+/g)?.map((s)=>s.slice(1)) || [];
             const params = Object.fromEntries(paramNames.map((name)=>[

package/dist/cjs/utils/crossProjectApiPlugin.js

@@ -37,107 +37,50 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    API_DIR: ()=>API_DIR,
-    DIST_DIR: ()=>DIST_DIR,
-    EFFECT_ENTRY: ()=>EFFECT_ENTRY,
-    LAMBDA_DIR: ()=>LAMBDA_DIR,
-    OPERATION_CONTRACTS_JSON: ()=>OPERATION_CONTRACTS_JSON,
-    PACKAGE_NAME: ()=>PACKAGE_NAME,
-    PREFIX: ()=>PREFIX,
-    REQUEST_ID: ()=>REQUEST_ID,
-    RUNTIME_FRAMEWORK: ()=>RUNTIME_FRAMEWORK,
-    crossProjectApiPlugin: ()=>crossProjectApiPlugin,
-    default: ()=>utils_crossProjectApiPlugin
+    createCrossProjectApiPlugin: ()=>createCrossProjectApiPlugin,
+    default: ()=>crossProjectApiPlugin
 });
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
-const PACKAGE_NAME = '{packageName}';
-const REQUEST_ID = '{requestId}';
-const PREFIX = '{prefix}';
-const API_DIR = '{apiDirectory}';
-const LAMBDA_DIR = '{lambdaDirectory}';
-const DIST_DIR = '{distDirectory}';
-const RUNTIME_FRAMEWORK = '{runtimeFramework}';
-const EFFECT_ENTRY = '{effectEntry}';
-const OPERATION_CONTRACTS_JSON = '{operationContracts}';
-const NODE_MODULES = 'node_modules';
-const crossProjectApiPlugin = ()=>({
+const createCrossProjectApiPlugin = (options)=>({
         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 effectEntry = EFFECT_ENTRY ? external_path_default().join(sdkDistPath, EFFECT_ENTRY) : void 0;
-                const apiDirectory = effectEntry ? external_path_default().dirname(effectEntry) : external_path_default().join(sdkDistPath, API_DIR);
-                const lambdaDirectory = external_path_default().resolve(sdkDistPath, LAMBDA_DIR);
+            api.modifyResolvedConfig(async (resolvedConfig)=>{
+                const { appDirectory } = api.getAppContext();
+                const sdkDirectory = external_path_default().join(appDirectory, 'node_modules', options.packageName);
+                const sdkDistDirectory = external_path_default().join(sdkDirectory, options.relativeDistPath);
+                const apiDirectory = external_path_default().join(sdkDistDirectory, options.relativeApiPath);
+                const lambdaDirectory = external_path_default().resolve(sdkDistDirectory, options.relativeLambdaPath);
+                const configuredPrefix = api.getConfig()?.bff?.prefix;
+                if (configuredPrefix) {
+                    const isSamePrefix = Array.isArray(configuredPrefix) ? 1 === configuredPrefix.length && configuredPrefix[0] === options.prefix : configuredPrefix === options.prefix;
+                    if (!isSamePrefix) throw new Error(`[${options.packageName}] Invalid bff.prefix for cross-project BFF. Detected "${configuredPrefix}", expected "${options.prefix}". Remove bff.prefix from the consumer app, or set it exactly to "${options.prefix}".`);
+                }
                 api.updateAppContext({
                     apiDirectory,
-                    lambdaDirectory,
-                    bffRuntimeFramework: RUNTIME_FRAMEWORK
+                    lambdaDirectory
                 });
-                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 ??= {};
-                resolvedConfig.bff.prefix = PREFIX;
-                resolvedConfig.bff.runtimeFramework = RUNTIME_FRAMEWORK;
-                if (EFFECT_ENTRY) resolvedConfig.bff.effect = {
-                    ...resolvedConfig.bff.effect,
-                    entry: effectEntry
-                };
+                resolvedConfig.bff.prefix = options.prefix;
                 resolvedConfig.bff.isCrossProjectServer = true;
-                resolvedConfig.bff.requestId = resolvedConfig.bff.requestId || config?.bff?.requestId || REQUEST_ID || PACKAGE_NAME || 'default';
-                const generatedOperationContracts = "{operationContracts}" === OPERATION_CONTRACTS_JSON ? {} : JSON.parse(OPERATION_CONTRACTS_JSON);
-                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,
-                    expectedOperationContracts: {
-                        ...resolvedConfig.bff.crossProjectPolicy?.expectedOperationContracts || {},
-                        ...generatedOperationContracts
-                    }
-                };
-                return resolvedConfig;
+                return options.modifyResolvedConfig ? options.modifyResolvedConfig(resolvedConfig, {
+                    sdkDirectory,
+                    sdkDistDirectory,
+                    apiDirectory,
+                    lambdaDirectory,
+                    api
+                }) : resolvedConfig;
             });
         }
     });
-const utils_crossProjectApiPlugin = crossProjectApiPlugin;
-exports.API_DIR = __webpack_exports__.API_DIR;
-exports.DIST_DIR = __webpack_exports__.DIST_DIR;
-exports.EFFECT_ENTRY = __webpack_exports__.EFFECT_ENTRY;
-exports.LAMBDA_DIR = __webpack_exports__.LAMBDA_DIR;
-exports.OPERATION_CONTRACTS_JSON = __webpack_exports__.OPERATION_CONTRACTS_JSON;
-exports.PACKAGE_NAME = __webpack_exports__.PACKAGE_NAME;
-exports.PREFIX = __webpack_exports__.PREFIX;
-exports.REQUEST_ID = __webpack_exports__.REQUEST_ID;
-exports.RUNTIME_FRAMEWORK = __webpack_exports__.RUNTIME_FRAMEWORK;
-exports.crossProjectApiPlugin = __webpack_exports__.crossProjectApiPlugin;
+const crossProjectApiPlugin = createCrossProjectApiPlugin;
+exports.createCrossProjectApiPlugin = __webpack_exports__.createCrossProjectApiPlugin;
 exports["default"] = __webpack_exports__["default"];
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "API_DIR",
-    "DIST_DIR",
-    "EFFECT_ENTRY",
-    "LAMBDA_DIR",
-    "OPERATION_CONTRACTS_JSON",
-    "PACKAGE_NAME",
-    "PREFIX",
-    "REQUEST_ID",
-    "RUNTIME_FRAMEWORK",
-    "crossProjectApiPlugin",
+    "createCrossProjectApiPlugin",
     "default"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/utils/pluginGenerator.js

@@ -37,40 +37,40 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    default: ()=>utils_pluginGenerator
+    default: ()=>pluginGenerator,
+    renderBffPlugin: ()=>renderBffPlugin
 });
 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_crossProjectApiPlugin_js_namespaceObject = require("./crossProjectApiPlugin.js");
-function replaceContent(source, packageName, requestId, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts) {
-    const updatedSource = source.replace(new RegExp(external_crossProjectApiPlugin_js_namespaceObject.PACKAGE_NAME, 'g'), packageName).replace(new RegExp(external_crossProjectApiPlugin_js_namespaceObject.REQUEST_ID, 'g'), requestId).replace(new RegExp(external_crossProjectApiPlugin_js_namespaceObject.PREFIX, 'g'), prefix).replace(new RegExp(external_crossProjectApiPlugin_js_namespaceObject.DIST_DIR, 'g'), (0, utils_namespaceObject.normalizeToPosixPath)(relativeDistPath)).replace(new RegExp(external_crossProjectApiPlugin_js_namespaceObject.API_DIR, 'g'), (0, utils_namespaceObject.normalizeToPosixPath)(relativeApiPath)).replace(new RegExp(external_crossProjectApiPlugin_js_namespaceObject.LAMBDA_DIR, 'g'), (0, utils_namespaceObject.normalizeToPosixPath)(relativeLambdaPath)).replace(new RegExp(external_crossProjectApiPlugin_js_namespaceObject.RUNTIME_FRAMEWORK, 'g'), runtimeFramework).replace(new RegExp(external_crossProjectApiPlugin_js_namespaceObject.EFFECT_ENTRY, 'g'), (0, utils_namespaceObject.normalizeToPosixPath)(relativeEffectEntry)).replace(`'${external_crossProjectApiPlugin_js_namespaceObject.OPERATION_CONTRACTS_JSON}'`, ()=>JSON.stringify(JSON.stringify(operationContracts)));
-    return updatedSource;
+async function renderBffPlugin(options) {
+    const packageJson = await utils_namespaceObject.fs.readJSON(external_path_default().resolve(options.appDirectory, 'package.json'));
+    const descriptor = {
+        packageName: packageJson.name,
+        prefix: options.prefix,
+        relativeDistPath: (0, utils_namespaceObject.normalizeToPosixPath)(options.relativeDistPath),
+        relativeApiPath: (0, utils_namespaceObject.normalizeToPosixPath)(options.relativeApiPath),
+        relativeLambdaPath: (0, utils_namespaceObject.normalizeToPosixPath)(options.relativeLambdaPath)
+    };
+    return {
+        code: 'module' === packageJson.type ? `import { createCrossProjectApiPlugin } from '@modern-js/plugin-bff/cross-project';\nexport const crossProjectApiPlugin = () => createCrossProjectApiPlugin(${JSON.stringify(descriptor)});\n` : `'use strict';\nconst { createCrossProjectApiPlugin } = require('@modern-js/plugin-bff/cross-project');\nexports.crossProjectApiPlugin = () => createCrossProjectApiPlugin(${JSON.stringify(descriptor)});\n`,
+        declaration: `import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+export declare const crossProjectApiPlugin: () => CliPlugin<AppTools>;
+`
+    };
 }
-async function pluginGenerator({ prefix, appDirectory, requestId, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts }) {
-    try {
-        const packageContent = await utils_namespaceObject.fs.readFile(external_path_default().resolve(appDirectory, './package.json'), 'utf8');
-        const packageJson = JSON.parse(packageContent);
-        const pluginDir = external_path_default().resolve(appDirectory, `./${relativeDistPath}`, 'plugin');
-        const pluginPath = external_path_default().join(pluginDir, 'index.js');
-        const pluginTemplate = await utils_namespaceObject.fs.readFile(external_path_default().resolve(__dirname, 'crossProjectApiPlugin.js'), 'utf8');
-        const updatedPlugin = replaceContent(pluginTemplate, packageJson.name, requestId, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts);
-        await utils_namespaceObject.fs.ensureFile(pluginPath);
-        await utils_namespaceObject.fs.writeFile(pluginPath, updatedPlugin);
-        const typeContent = `import type { AppTools, CliPlugin } from '@modern-js/app-tools';
-      export declare const crossProjectApiPlugin: () => CliPlugin<AppTools>`;
-        const pluginTypePath = external_path_default().join(pluginDir, 'index.d.ts');
-        await utils_namespaceObject.fs.ensureFile(pluginTypePath);
-        await utils_namespaceObject.fs.writeFile(pluginTypePath, typeContent);
-        utils_namespaceObject.logger.info('Api plugin generate succeed');
-    } catch (error) {
-        utils_namespaceObject.logger.error('Api plugin generate failed:', error);
-    }
+async function pluginGenerator(options, rendered) {
+    const module = rendered ?? await renderBffPlugin(options);
+    const directory = external_path_default().resolve(options.appDirectory, options.relativeDistPath, 'plugin');
+    await utils_namespaceObject.fs.outputFile(external_path_default().join(directory, 'index.js'), module.code);
+    await utils_namespaceObject.fs.outputFile(external_path_default().join(directory, 'index.d.ts'), module.declaration);
+    utils_namespaceObject.logger.info('Api plugin generate succeed');
 }
-const utils_pluginGenerator = pluginGenerator;
 exports["default"] = __webpack_exports__["default"];
+exports.renderBffPlugin = __webpack_exports__.renderBffPlugin;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "default"
+    "default",
+    "renderBffPlugin"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/utils/runtimeGenerator.js

@@ -37,88 +37,39 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    default: ()=>utils_runtimeGenerator
+    default: ()=>runtimeGenerator,
+    renderBffRuntime: ()=>renderBffRuntime
 });
-const cross_project_generation_namespaceObject = require("@modern-js/plugin-bff-extensions/cross-project-generation");
+const external_node_url_namespaceObject = require("node:url");
 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 getPackageName = (appDirectory)=>{
-    try {
-        const packageJsonPath = external_path_default().resolve(appDirectory, './package.json');
-        const packageJson = require(packageJsonPath);
-        return packageJson.name;
-    } catch (error) {
-        return;
-    }
-};
-async function runtimeGenerator({ runtime, appDirectory, relativeDistPath, packageName }) {
-    const pluginDir = external_path_default().resolve(appDirectory, `./${relativeDistPath}`, 'runtime');
-    const requestId = packageName || getPackageName(appDirectory) || process.env.npm_package_name || 'default';
-    const runtimeImportPath = JSON.stringify(runtime);
-    const requestIdValue = JSON.stringify(requestId);
-    const source = `'use strict'; const { configure: _configure } = require(${runtimeImportPath});
-    const defaultSecureOptions = ${(0, cross_project_generation_namespaceObject.renderProducerRuntimeDefaults)(requestIdValue)};
-    const initProducerClient = (options) => {
-      return _configure({
-        ...defaultSecureOptions,
-        ...options,
-        identityBinding: {
-          ...defaultSecureOptions.identityBinding,
-          ...(options && options.identityBinding ? options.identityBinding : {}),
-        },
-        operationContract: {
-          ...defaultSecureOptions.operationContract,
-          ...(options && options.operationContract ? options.operationContract : {}),
-        },
-      });
-    }
-    const configure = initProducerClient;
-    Object.defineProperty(exports, '__esModule', { value: true });
-    exports.initProducerClient = initProducerClient;
-    exports.configure = configure;
-  `;
-    const pluginPath = external_path_default().join(pluginDir, 'index.js');
-    await utils_namespaceObject.fs.ensureFile(pluginPath);
-    await utils_namespaceObject.fs.writeFile(pluginPath, source);
-    const tsSource = `type ProducerRuntimeModule = typeof import(${runtimeImportPath});
-  type ProducerClientOptions = ProducerRuntimeModule extends {
-    configure: (options: infer TOptions) => unknown;
-  }
-    ? TOptions
-    : {
-        request?: typeof fetch;
-        interceptor?: (request: typeof fetch) => typeof fetch;
-        allowedHeaders?: string[];
-        requireEnvelope?: boolean;
-        allowCrossOriginEnvelope?: boolean;
-        identityBinding?: {
-          enabled?: boolean;
-          strict?: boolean;
-          protectedHeaders?: string[];
-        };
-        operationContract?: {
-          enabled?: boolean;
-          strict?: boolean;
-          requireSchemaHash?: boolean;
-          requireOperationVersion?: boolean;
-        };
-        setDomain?: (ops?: {
-          target: 'server' | 'browser';
-          requestId?: string;
-        }) => string;
-        requestId?: string;
-      };
-  export declare const initProducerClient: (options?: ProducerClientOptions) => ReturnType<ProducerRuntimeModule['configure']>;
-  export declare const configure: typeof initProducerClient;`;
-    const pluginTypePath = external_path_default().join(pluginDir, 'index.d.ts');
-    await utils_namespaceObject.fs.ensureFile(pluginTypePath);
-    await utils_namespaceObject.fs.writeFile(pluginTypePath, tsSource);
+function renderBffRuntime(options) {
+    const packagePath = external_path_default().resolve(options.appDirectory, 'package.json');
+    const packageJson = utils_namespaceObject.fs.existsSync(packagePath) ? utils_namespaceObject.fs.readJSONSync(packagePath) : {};
+    const requestId = options.packageName || packageJson.name || process.env.npm_package_name || 'default';
+    const runtime = JSON.stringify(options.runtime);
+    const esmRuntime = JSON.stringify(external_path_default().isAbsolute(options.runtime) ? (0, external_node_url_namespaceObject.pathToFileURL)(options.runtime).href : options.runtime);
+    return {
+        code: 'module' === packageJson.type ? `import { configure as _configure } from ${esmRuntime};\nexport const initProducerClient = options => _configure({ requestId: ${JSON.stringify(requestId)}, ...options });\nexport const configure = initProducerClient;\n` : `'use strict';\nconst { configure: _configure } = require(${runtime});\nconst initProducerClient = options => _configure({ requestId: ${JSON.stringify(requestId)}, ...options });\nexports.initProducerClient = initProducerClient;\nexports.configure = initProducerClient;\n`,
+        declaration: `type Runtime = typeof import(${runtime});
+export declare const initProducerClient: (options?: Parameters<Runtime['configure']>[0]) => ReturnType<Runtime['configure']>;
+export declare const configure: typeof initProducerClient;
+`
+    };
+}
+async function runtimeGenerator(options, rendered) {
+    const directory = external_path_default().resolve(options.appDirectory, options.relativeDistPath, 'runtime');
+    if (null === rendered) return void await utils_namespaceObject.fs.remove(directory);
+    const module = rendered ?? renderBffRuntime(options);
+    await utils_namespaceObject.fs.outputFile(external_path_default().join(directory, 'index.js'), module.code);
+    await utils_namespaceObject.fs.outputFile(external_path_default().join(directory, 'index.d.ts'), module.declaration);
 }
-const utils_runtimeGenerator = runtimeGenerator;
 exports["default"] = __webpack_exports__["default"];
+exports.renderBffRuntime = __webpack_exports__.renderBffRuntime;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "default"
+    "default",
+    "renderBffRuntime"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true