@bleedingdev/modern-js-plugin-bff 3.9.0-ultramodern.4 → 3.9.0-ultramodern.5

package/dist/esm-node/utils/client-generator/generate.mjs

@@ -1,20 +1,19 @@
 import "node:module";
-import { generateClient } from "@modern-js/bff-core";
+import { ClientCodegenError, generateClient } from "@modern-js/bff-core";
 import { fs, logger } from "@modern-js/utils";
 import path from "path";
 import { CLIENT_DIR, createFileDetails, readDirectoryFiles, writeTargetFile } from "./files.mjs";
 import { getPackageName } from "./package-json.mjs";
 import { DEFAULT_EXPORT_RE, buildClientTypeFacade, createMissingClientDeclarationError, isMissingClientDeclarationError } from "./type-facade.mjs";
 import { setPackage, writeClientModuleBoundary } from "./write-package.mjs";
-async function clientGenerator(draftOptions) {
+async function clientGenerator(draftOptions, integration) {
     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 requestId = draftOptions.requestId || getPackageName(draftOptions.appDir) || process.env.npm_package_name;
     const lambdaSourceList = draftOptions.existLambda ? await 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 logger.warn(warning);
@@ -29,6 +28,7 @@ async function clientGenerator(draftOptions) {
             target: 'bundle',
             httpMethodDecider: draftOptions.httpMethodDecider,
             requestCreator: draftOptions.requestCreator,
+            clientCodegenPlugin: draftOptions.clientCodegenPlugin,
             requestId
         };
         const { lambdaDir } = draftOptions;
@@ -37,9 +37,9 @@ async function clientGenerator(draftOptions) {
         return result;
     };
     const writeClientTypeFacade = async (source, clientCode)=>{
-        if (!await fs.pathExists(path.resolve(source.relativeTargetDistDir))) throw createMissingClientDeclarationError(source.resourcePath, source.relativeTargetDistDir);
-        const clientTypesFile = source.targetDir.replace(/\.js$/, '.d.ts');
-        await writeTargetFile(path.resolve(clientTypesFile), buildClientTypeFacade(clientTypesFile, source.relativeTargetDistDir, DEFAULT_EXPORT_RE.test(clientCode), true));
+        if (!await fs.pathExists(path.resolve(draftOptions.appDir, source.relativeTargetDistDir))) throw createMissingClientDeclarationError(source.resourcePath, path.resolve(draftOptions.appDir, source.relativeTargetDistDir));
+        const clientTypesFile = source.absTargetDir.replace(/\.js$/, '.d.ts');
+        await writeTargetFile(path.resolve(clientTypesFile), buildClientTypeFacade(clientTypesFile, path.resolve(draftOptions.appDir, source.relativeTargetDistDir), DEFAULT_EXPORT_RE.test(clientCode), true));
     };
     try {
         for (const source of lambdaSourceList){
@@ -49,50 +49,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 fs.readFile(effectEntryFile, 'utf8');
-                const effectFileDetails = 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 writeTargetFile(effectFileDetails.absTargetDir, generatedEffectClient.code);
-                    await writeTargetFile(path.resolve(targetTypeFile), generatedEffectClient.declaration);
-                    generatedSourceList.push(effectFileDetails);
-                }
-            }
-        }
         logger.info("Client bundle generate succeed");
     } catch (error) {
-        if (isMissingClientDeclarationError(error)) throw error;
+        if (isMissingClientDeclarationError(error) || error instanceof ClientCodegenError) throw error;
         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)=>path.resolve(file.resourcePath)));
+        const exportKeys = new Set(generatedSourceList.map((file)=>file.exportKey));
+        const outputPaths = new Set(generatedSourceList.map((file)=>path.resolve(file.absTargetDir)));
+        const additionalFiles = artifacts.additionalArtifacts.map((artifact)=>{
+            const relative = artifact.sourcePath;
+            const resourcePath = path.resolve(draftOptions.apiDir, relative);
+            if (!relative || path.isAbsolute(relative) || relative.includes('\\') || path.relative(draftOptions.apiDir, resourcePath).split(path.sep).includes('..') || path.relative(draftOptions.apiDir, resourcePath).split(path.sep).join('/') !== relative || !/\.[cm]?[jt]sx?$/.test(relative)) throw new Error(`Invalid BFF client artifact source path: ${relative}`);
+            const file = createFileDetails({
+                appDirectory: draftOptions.appDir,
+                baseDirectory: draftOptions.apiDir,
+                resourcePath,
+                source: '',
+                relativeDistPath: draftOptions.relativeDistPath
+            });
+            if (sourcePaths.has(resourcePath) || exportKeys.has(file.exportKey) || outputPaths.has(path.resolve(file.absTargetDir))) throw new Error(`BFF client artifact collision: ${relative}`);
+            sourcePaths.add(resourcePath);
+            exportKeys.add(file.exportKey);
+            outputPaths.add(path.resolve(file.absTargetDir));
+            return {
+                file,
+                artifact
+            };
+        });
+        for (const { file, artifact } of additionalFiles){
+            await writeTargetFile(file.absTargetDir, artifact.code);
+            await writeTargetFile(file.absTargetDir.replace(/\.js$/, '.d.ts'), artifact.declaration);
+            generatedSourceList.push(file);
+        }
+        packageDependencies = await integration.beforePublish() || void 0;
+    }
     if (generatedSourceList.length > 0) await writeClientModuleBoundary(draftOptions.appDir, draftOptions.relativeDistPath);
-    await setPackage(generatedSourceList, draftOptions.appDir, draftOptions.relativeDistPath);
-    return generatedEffectClient;
+    await setPackage(generatedSourceList, draftOptions.appDir, draftOptions.relativeDistPath, packageDependencies);
+    return null;
 }
 const generate = clientGenerator;
 export default generate;

package/dist/esm-node/utils/client-generator/write-package.mjs

@@ -10,10 +10,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 = path.resolve(appDirectory, './package.json');
     const packageContent = await 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));

package/dist/esm-node/utils/crossProjectApiPlugin.mjs

@@ -1,69 +1,39 @@
 import "node:module";
 import path from "path";
-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 = path.join(originAppDirectory, NODE_MODULES, PACKAGE_NAME);
-                const sdkDistPath = path.join(sdkPath, DIST_DIR);
-                const effectEntry = EFFECT_ENTRY ? path.join(sdkDistPath, EFFECT_ENTRY) : void 0;
-                const apiDirectory = effectEntry ? path.dirname(effectEntry) : path.join(sdkDistPath, API_DIR);
-                const lambdaDirectory = path.resolve(sdkDistPath, LAMBDA_DIR);
+            api.modifyResolvedConfig(async (resolvedConfig)=>{
+                const { appDirectory } = api.getAppContext();
+                const sdkDirectory = path.join(appDirectory, 'node_modules', options.packageName);
+                const sdkDistDirectory = path.join(sdkDirectory, options.relativeDistPath);
+                const apiDirectory = path.join(sdkDistDirectory, options.relativeApiPath);
+                const lambdaDirectory = path.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;
-export default utils_crossProjectApiPlugin;
-export { API_DIR, DIST_DIR, EFFECT_ENTRY, LAMBDA_DIR, OPERATION_CONTRACTS_JSON, PACKAGE_NAME, PREFIX, REQUEST_ID, RUNTIME_FRAMEWORK, crossProjectApiPlugin };
+const crossProjectApiPlugin = createCrossProjectApiPlugin;
+export default crossProjectApiPlugin;
+export { createCrossProjectApiPlugin };

package/dist/esm-node/utils/pluginGenerator.mjs

@@ -1,33 +1,28 @@
 import "node:module";
 import { fs, logger, normalizeToPosixPath } from "@modern-js/utils";
 import path from "path";
-import { API_DIR, DIST_DIR, EFFECT_ENTRY, LAMBDA_DIR, OPERATION_CONTRACTS_JSON, PACKAGE_NAME, PREFIX, REQUEST_ID, RUNTIME_FRAMEWORK } from "./crossProjectApiPlugin.mjs";
-import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
-import { dirname as __rspack_dirname } from "node:path";
-var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-function replaceContent(source, packageName, requestId, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts) {
-    const updatedSource = source.replace(new RegExp(PACKAGE_NAME, 'g'), packageName).replace(new RegExp(REQUEST_ID, 'g'), requestId).replace(new RegExp(PREFIX, 'g'), prefix).replace(new RegExp(DIST_DIR, 'g'), normalizeToPosixPath(relativeDistPath)).replace(new RegExp(API_DIR, 'g'), normalizeToPosixPath(relativeApiPath)).replace(new RegExp(LAMBDA_DIR, 'g'), normalizeToPosixPath(relativeLambdaPath)).replace(new RegExp(RUNTIME_FRAMEWORK, 'g'), runtimeFramework).replace(new RegExp(EFFECT_ENTRY, 'g'), normalizeToPosixPath(relativeEffectEntry)).replace(`'${OPERATION_CONTRACTS_JSON}'`, ()=>JSON.stringify(JSON.stringify(operationContracts)));
-    return updatedSource;
+async function renderBffPlugin(options) {
+    const packageJson = await fs.readJSON(path.resolve(options.appDirectory, 'package.json'));
+    const descriptor = {
+        packageName: packageJson.name,
+        prefix: options.prefix,
+        relativeDistPath: normalizeToPosixPath(options.relativeDistPath),
+        relativeApiPath: normalizeToPosixPath(options.relativeApiPath),
+        relativeLambdaPath: 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 fs.readFile(path.resolve(appDirectory, './package.json'), 'utf8');
-        const packageJson = JSON.parse(packageContent);
-        const pluginDir = path.resolve(appDirectory, `./${relativeDistPath}`, 'plugin');
-        const pluginPath = path.join(pluginDir, 'index.js');
-        const pluginTemplate = await fs.readFile(path.resolve(__rspack_import_meta_dirname__, 'crossProjectApiPlugin.js'), 'utf8');
-        const updatedPlugin = replaceContent(pluginTemplate, packageJson.name, requestId, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts);
-        await fs.ensureFile(pluginPath);
-        await fs.writeFile(pluginPath, updatedPlugin);
-        const typeContent = `import type { AppTools, CliPlugin } from '@modern-js/app-tools';
-      export declare const crossProjectApiPlugin: () => CliPlugin<AppTools>`;
-        const pluginTypePath = path.join(pluginDir, 'index.d.ts');
-        await fs.ensureFile(pluginTypePath);
-        await fs.writeFile(pluginTypePath, typeContent);
-        logger.info('Api plugin generate succeed');
-    } catch (error) {
-        logger.error('Api plugin generate failed:', error);
-    }
+async function pluginGenerator(options, rendered) {
+    const module = rendered ?? await renderBffPlugin(options);
+    const directory = path.resolve(options.appDirectory, options.relativeDistPath, 'plugin');
+    await fs.outputFile(path.join(directory, 'index.js'), module.code);
+    await fs.outputFile(path.join(directory, 'index.d.ts'), module.declaration);
+    logger.info('Api plugin generate succeed');
 }
-const utils_pluginGenerator = pluginGenerator;
-export default utils_pluginGenerator;
+export default pluginGenerator;
+export { renderBffPlugin };

package/dist/esm-node/utils/runtimeGenerator.mjs

@@ -1,79 +1,26 @@
-import __rslib_shim_module__ from "node:module";
-const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import { renderProducerRuntimeDefaults } from "@modern-js/plugin-bff-extensions/cross-project-generation";
+import "node:module";
+import { pathToFileURL } from "node:url";
 import { fs } from "@modern-js/utils";
 import path from "path";
-const getPackageName = (appDirectory)=>{
-    try {
-        const packageJsonPath = path.resolve(appDirectory, './package.json');
-        const packageJson = require(packageJsonPath);
-        return packageJson.name;
-    } catch (error) {
-        return;
-    }
-};
-async function runtimeGenerator({ runtime, appDirectory, relativeDistPath, packageName }) {
-    const pluginDir = path.resolve(appDirectory, `./${relativeDistPath}`, 'runtime');
-    const requestId = packageName || getPackageName(appDirectory) || process.env.npm_package_name || 'default';
-    const runtimeImportPath = JSON.stringify(runtime);
-    const requestIdValue = JSON.stringify(requestId);
-    const source = `'use strict'; const { configure: _configure } = require(${runtimeImportPath});
-    const defaultSecureOptions = ${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 = path.join(pluginDir, 'index.js');
-    await fs.ensureFile(pluginPath);
-    await 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 = path.join(pluginDir, 'index.d.ts');
-    await fs.ensureFile(pluginTypePath);
-    await fs.writeFile(pluginTypePath, tsSource);
+function renderBffRuntime(options) {
+    const packagePath = path.resolve(options.appDirectory, 'package.json');
+    const packageJson = fs.existsSync(packagePath) ? 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(path.isAbsolute(options.runtime) ? 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;
+`
+    };
 }
-const utils_runtimeGenerator = runtimeGenerator;
-export default utils_runtimeGenerator;
+async function runtimeGenerator(options, rendered) {
+    const module = rendered ?? renderBffRuntime(options);
+    const directory = path.resolve(options.appDirectory, options.relativeDistPath, 'runtime');
+    await fs.outputFile(path.join(directory, 'index.js'), module.code);
+    await fs.outputFile(path.join(directory, 'index.d.ts'), module.declaration);
+}
+export default runtimeGenerator;
+export { renderBffRuntime };

package/dist/types/cli/generator.d.ts

@@ -1,7 +1,7 @@
 import type { AppTools } from '@modern-js/app-tools';
 import type { CLIPluginAPI } from '@modern-js/plugin';
 export declare const createBffGenerator: (api: CLIPluginAPI<AppTools>) => {
-    compileApi: () => Promise<void | undefined>;
+    compileApi: () => Promise<void>;
     generate: () => Promise<void>;
-    handleCrossProjectInvocation: (isBuild?: boolean) => Promise<void | undefined>;
+    handleCrossProjectInvocation: (isBuild?: boolean) => Promise<void>;
 };

package/dist/types/loader.d.ts

@@ -9,20 +9,10 @@ export type APILoaderOptions = {
     port: number;
     fetcher?: string;
     requestCreator?: string;
+    clientCodegenPlugin?: string;
     requestId?: string;
     target: string;
     httpMethodDecider?: HttpMethodDecider;
-    bffRuntimeFramework?: 'hono' | 'effect';
-    effectEntry?: string;
-    effectDataPlatformBatch?: {
-        enabled?: boolean;
-        endpoint?: string;
-        flushIntervalMs?: number;
-        maxBatchSize?: number;
-        maxBatchBytes?: number;
-        requestTimeoutMs?: number;
-        allowedMethods?: string[];
-    };
 };
 declare function loader(this: Rspack.LoaderContext<APILoaderOptions>, source: string): Promise<void>;
 export default loader;

package/dist/types/runtime/create-request/index.d.ts

@@ -1,3 +1 @@
-import { configure, createRequest, createRequestContextHeaders, createRequestContextSnapshot, createUploader } from '@modern-js/create-request';
-export type { OperationContext, OperationContextSource, RequestContextInput, RequestContextSnapshot, } from '@modern-js/create-request';
-export { configure, createRequest, createRequestContextHeaders, createRequestContextSnapshot, createUploader, };
+export { configure, createRequest, createUploader, } from '@modern-js/create-request';

package/dist/types/runtime/hono/adapter.d.ts

@@ -1,9 +1,16 @@
-import type { ServerMiddleware, ServerPluginAPI } from '@modern-js/server-core';
+import type { APIHandlerInfo } from '@modern-js/bff-core';
+import type { MiddlewareHandler, ServerMiddleware, ServerPluginAPI } from '@modern-js/server-core';
+export type HonoRouteBinder = (options: {
+    handler: MiddlewareHandler | MiddlewareHandler[];
+    routePath: string;
+}) => MiddlewareHandler | MiddlewareHandler[];
+export type HonoRouteBinderFactory = (api: ServerPluginAPI, handlers: APIHandlerInfo[]) => HonoRouteBinder;
 export declare class HonoAdapter {
+    private readonly createRouteBinder?;
     apiMiddleware: ServerMiddleware[];
     api: ServerPluginAPI;
     isHono: boolean;
-    constructor(api: ServerPluginAPI);
+    constructor(api: ServerPluginAPI, createRouteBinder?: HonoRouteBinderFactory | undefined);
     setHandlers: () => Promise<void>;
     /**
      * Register the BFF API routes as ordinary server middlewares.

package/dist/types/server.d.ts

@@ -1,3 +1,10 @@
-import type { ServerPlugin } from '@modern-js/server-core';
+import type { BffUserConfig, ServerPlugin } from '@modern-js/server-core';
+type RuntimeFramework = NonNullable<BffUserConfig['runtimeFramework']>;
+export type BffServerPluginOptions = {
+    honoRouteBinder?: string;
+    runtimeAdapters?: {
+        [Runtime in RuntimeFramework]?: Runtime extends 'hono' ? never : string;
+    };
+};
 export default _default;
-declare function _default(): ServerPlugin;
+declare function _default(options?: BffServerPluginOptions): ServerPlugin;

package/dist/types/utils/client-generator/generate.d.ts

@@ -1,3 +1,4 @@
+import type { BffClientArtifacts, BffGeneration } from '@modern-js/app-tools';
 import type { HttpMethodDecider } from '@modern-js/types';
 export type APILoaderOptions = {
     prefix: string;
@@ -7,6 +8,7 @@ export type APILoaderOptions = {
     existLambda: boolean;
     port?: number;
     requestCreator?: string;
+    clientCodegenPlugin?: string;
     httpMethodDecider?: HttpMethodDecider;
     relativeDistPath: string;
     relativeApiPath: string;
@@ -19,17 +21,11 @@ export type APILoaderOptions = {
      * private files) never reach `generateClient`.
      */
     apiFiles: string[];
-    bffRuntimeFramework?: 'hono' | 'effect';
-    effectEntry?: string;
-    effectDataPlatformBatch?: {
-        enabled?: boolean;
-        endpoint?: string;
-        flushIntervalMs?: number;
-        maxBatchSize?: number;
-        maxBatchBytes?: number;
-        requestTimeoutMs?: number;
-        allowedMethods?: string[];
-    };
 };
-export declare function clientGenerator(draftOptions: APILoaderOptions): Promise<import("@modern-js/plugin-bff-extensions/client-generator").GeneratedEffectClientArtifacts | null>;
+export interface ClientGenerationIntegration {
+    generation: BffGeneration;
+    modifyArtifacts: (context: BffClientArtifacts) => Promise<BffClientArtifacts>;
+    beforePublish: () => Promise<Record<string, string> | void>;
+}
+export declare function clientGenerator(draftOptions: APILoaderOptions, integration?: ClientGenerationIntegration): Promise<null>;
 export default clientGenerator;

package/dist/types/utils/client-generator/write-package.d.ts

@@ -3,4 +3,4 @@ export declare function setPackage(files: {
     exportKey: string;
     targetDir: string;
     relativeTargetDistDir: string;
-}[], appDirectory: string, relativeDistPath: string): Promise<void>;
+}[], appDirectory: string, relativeDistPath: string, packageDependencies?: Record<string, string>): Promise<void>;

package/dist/types/utils/crossProjectApiPlugin.d.ts

@@ -1,12 +1,18 @@
-import type { AppTools, CliPlugin } from '@modern-js/app-tools';
-export declare const PACKAGE_NAME = "{packageName}";
-export declare const REQUEST_ID = "{requestId}";
-export declare const PREFIX = "{prefix}";
-export declare const API_DIR = "{apiDirectory}";
-export declare const LAMBDA_DIR = "{lambdaDirectory}";
-export declare const DIST_DIR = "{distDirectory}";
-export declare const RUNTIME_FRAMEWORK: string;
-export declare const EFFECT_ENTRY = "{effectEntry}";
-export declare const OPERATION_CONTRACTS_JSON = "{operationContracts}";
-export declare const crossProjectApiPlugin: () => CliPlugin<AppTools>;
-export default crossProjectApiPlugin;
+import type { AppTools, AppToolsNormalizedConfig, CliPlugin } from '@modern-js/app-tools';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+export interface CrossProjectApiPluginOptions {
+    packageName: string;
+    prefix: string;
+    relativeDistPath: string;
+    relativeApiPath: string;
+    relativeLambdaPath: string;
+    modifyResolvedConfig?: (config: AppToolsNormalizedConfig, context: {
+        sdkDirectory: string;
+        sdkDistDirectory: string;
+        apiDirectory: string;
+        lambdaDirectory: string;
+        api: CLIPluginAPI<AppTools>;
+    }) => AppToolsNormalizedConfig | Promise<AppToolsNormalizedConfig>;
+}
+export declare const createCrossProjectApiPlugin: (options: CrossProjectApiPluginOptions) => CliPlugin<AppTools>;
+export default createCrossProjectApiPlugin;

package/dist/types/utils/pluginGenerator.d.ts

@@ -1,12 +1,11 @@
-declare function pluginGenerator({ prefix, appDirectory, requestId, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts, }: {
+import type { BffGeneratedModule } from '@modern-js/app-tools';
+interface PluginGeneratorOptions {
     prefix: string;
     appDirectory: string;
-    requestId: string;
     relativeDistPath: string;
     relativeApiPath: string;
     relativeLambdaPath: string;
-    runtimeFramework: 'hono' | 'effect';
-    relativeEffectEntry: string;
-    operationContracts: Record<string, unknown>;
-}): Promise<void>;
-export default pluginGenerator;
+}
+export declare function renderBffPlugin(options: PluginGeneratorOptions): Promise<BffGeneratedModule>;
+export default function pluginGenerator(options: PluginGeneratorOptions, rendered?: BffGeneratedModule): Promise<void>;
+export {};

package/dist/types/utils/runtimeGenerator.d.ts

@@ -1,7 +1,10 @@
-declare function runtimeGenerator({ runtime, appDirectory, relativeDistPath, packageName, }: {
+import type { BffGeneratedModule } from '@modern-js/app-tools';
+interface RuntimeGeneratorOptions {
     runtime: string;
     appDirectory: string;
     relativeDistPath: string;
     packageName?: string;
-}): Promise<void>;
-export default runtimeGenerator;
+}
+export declare function renderBffRuntime(options: RuntimeGeneratorOptions): BffGeneratedModule;
+export default function runtimeGenerator(options: RuntimeGeneratorOptions, rendered?: BffGeneratedModule): Promise<void>;
+export {};