@bleedingdev/modern-js-plugin-bff 3.8.3-ultramodern.1 → 3.8.3-ultramodern.3

package/dist/esm/runtime/effect-client/index.mjs

@@ -1,98 +1 @@
-import { createRequestContextHeaders } from "@modern-js/create-request";
-import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
-import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
-import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
-import { Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization } from "effect/unstable/rpc";
-import { getRpcSerializationLayer } from "../effect/rpcSerialization.mjs";
-import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
-import * as __rspack_external_effect_unstable_http_HttpClientError_4b9eaee6 from "effect/unstable/http/HttpClientError";
-import * as __rspack_external_effect_Data_2b3f4efb from "effect/Data";
-import * as __rspack_external_effect_Exit_1ca64b33 from "effect/Exit";
-import * as __rspack_external_effect_ManagedRuntime_bfe218e3 from "effect/ManagedRuntime";
-import * as __rspack_external_effect_Scope_f87b0bd6 from "effect/Scope";
-class EffectRpcClientError extends __rspack_external_effect_Data_2b3f4efb.TaggedError('EffectRpcClientError') {
-}
-function isRecord(value) {
-    return 'object' == typeof value && null !== value && !Array.isArray(value);
-}
-function applySelection(value, selection) {
-    if (true === selection || void 0 === selection) return value;
-    if (Array.isArray(value)) return value.map((item)=>applySelection(item, selection));
-    if (!isRecord(value) || !isRecord(selection)) return value;
-    const masked = {};
-    for (const key of Object.keys(selection)){
-        const selected = selection[key];
-        if (void 0 !== selected && key in value && (true === selected || isRecord(selected))) masked[key] = applySelection(value[key], selected);
-    }
-    return masked;
-}
-function view() {
-    return (selection)=>selection;
-}
-function mask(value, selection) {
-    return applySelection(value, selection);
-}
-function runEffectView(request, selection) {
-    return new Promise((resolve, reject)=>{
-        request.then((value)=>resolve(mask(value, selection)), (reason)=>reject(reason));
-    });
-}
-function makeEffectHttpApiClient(api, options) {
-    const requestContextHeaders = createRequestContextHeaders(options?.requestContext);
-    const transformClient = (client)=>{
-        const contextClient = 0 === Object.keys(requestContextHeaders).length ? client : client.pipe(HttpClient.mapRequest((request)=>{
-            let nextRequest = request;
-            for (const [header, value] of Object.entries(requestContextHeaders))if (void 0 === nextRequest.headers[header.toLowerCase()]) nextRequest = HttpClientRequest.setHeader(nextRequest, header, value);
-            return nextRequest;
-        }));
-        return 'function' == typeof options?.transformClient ? options.transformClient(contextClient) : contextClient;
-    };
-    return HttpApiClient.make(api, {
-        baseUrl: options?.baseUrl,
-        transformClient,
-        transformResponse: options?.transformResponse
-    }).pipe(__rspack_external_effect_Effect_41060786.provide(FetchHttpClient.layer));
-}
-function makeEffectRpcClient(group, options) {
-    const protocolLayer = __rspack_external_effect_Layer_69c46453.provide(RpcClient.layerProtocolHttp({
-        url: options.url
-    }), __rspack_external_effect_Layer_69c46453.mergeAll(getRpcSerializationLayer(options.serialization), FetchHttpClient.layer));
-    const middlewareLayer = options.middlewareLayer ?? __rspack_external_effect_Layer_69c46453.empty;
-    const runtimeLayer = __rspack_external_effect_Layer_69c46453.mergeAll(protocolLayer, middlewareLayer);
-    return __rspack_external_effect_Effect_41060786.tryPromise({
-        try: async ()=>{
-            const runtime = __rspack_external_effect_ManagedRuntime_bfe218e3.make(runtimeLayer);
-            const scope = await runtime.runPromise(__rspack_external_effect_Scope_f87b0bd6.make());
-            try {
-                const client = await runtime.runPromise(RpcClient.make(group, {
-                    flatten: options.flatten
-                }).pipe(__rspack_external_effect_Effect_41060786.provideService(__rspack_external_effect_Scope_f87b0bd6.Scope, scope)));
-                let disposed = false;
-                const clientWithDispose = Object.assign(client, {
-                    dispose: async ()=>{
-                        if (!disposed) {
-                            disposed = true;
-                            await runtime.runPromise(__rspack_external_effect_Scope_f87b0bd6.close(scope, __rspack_external_effect_Exit_1ca64b33["void"]));
-                        }
-                        await runtime.dispose();
-                    }
-                });
-                return clientWithDispose;
-            } catch (error) {
-                try {
-                    await runtime.runPromise(__rspack_external_effect_Scope_f87b0bd6.close(scope, __rspack_external_effect_Exit_1ca64b33["void"]));
-                } catch  {}
-                try {
-                    await runtime.dispose();
-                } catch  {}
-                throw error;
-            }
-        },
-        catch: (error)=>new EffectRpcClientError({
-                cause: error
-            })
-    });
-}
-const runEffectRequest = __rspack_external_effect_Effect_41060786.runPromise;
-export { EffectRpcClientError, HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, __rspack_external_effect_Effect_41060786 as Effect, __rspack_external_effect_Layer_69c46453 as Layer, __rspack_external_effect_Schema_6065f72d as Schema, __rspack_external_effect_unstable_http_HttpClientError_4b9eaee6 as HttpClientError, makeEffectHttpApiClient, makeEffectRpcClient, mask, runEffectRequest, runEffectView, view };
+export * from "@modern-js/bff-effect/effect-client";

package/dist/esm/runtime/effect-client/runtime.mjs

@@ -1,62 +1 @@
-import { configureGeneratedEffectClientRuntime } from "./batch.mjs";
-import { prepareEffectRequest } from "./envelope.mjs";
-import { createEffectRequestContext as external_request_context_mjs_createEffectRequestContext } from "./request-context.mjs";
-const createGeneratedEffectClient = (manifest, config, requestRuntime)=>{
-    const createRequest = requestRuntime.createRequest;
-    const configureRequest = 'function' == typeof requestRuntime.configure ? requestRuntime.configure : void 0;
-    const createRequestContextHeaders = 'function' == typeof requestRuntime.createRequestContextHeaders ? requestRuntime.createRequestContextHeaders : void 0;
-    const httpMethodDecider = config.httpMethodDecider || 'functionName';
-    const port = config.useEnvPort && "u" > typeof process && process.env && process.env.PORT ? process.env.PORT : config.port;
-    configureGeneratedEffectClientRuntime(config, configureRequest);
-    const createEffectRequestContext = (requestContext)=>external_request_context_mjs_createEffectRequestContext(createRequestContextHeaders, requestContext);
-    const client = {};
-    const operationManifest = {};
-    for (const endpoint of manifest.endpoints){
-        const operationId = `${endpoint.method}:${endpoint.routePath}`;
-        const operation = {
-            appNamespace: config.appNamespace,
-            apiId: endpoint.apiId,
-            group: endpoint.group,
-            endpoint: endpoint.endpoint,
-            operationId,
-            routePath: endpoint.routePath,
-            method: endpoint.method,
-            operationVersion: endpoint.operationVersion,
-            schemaHash: endpoint.schemaHash,
-            version: endpoint.operationVersion
-        };
-        const sender = createRequest({
-            path: endpoint.routePath,
-            method: endpoint.method,
-            port,
-            operationContext: {
-                operationId,
-                routePath: endpoint.routePath,
-                method: endpoint.method,
-                schemaHash: endpoint.schemaHash,
-                operationVersion: endpoint.operationVersion
-            },
-            httpMethodDecider,
-            ...config.requestId ? {
-                requestId: config.requestId
-            } : {}
-        });
-        const call = (request = {})=>sender(prepareEffectRequest({
-                endpoint,
-                operation,
-                request,
-                config,
-                createEffectRequestContext
-            }));
-        client[endpoint.group] ??= {};
-        client[endpoint.group][endpoint.endpoint] = call;
-        operationManifest[endpoint.group] ??= {};
-        operationManifest[endpoint.group][endpoint.endpoint] = operation;
-    }
-    return {
-        client,
-        operationManifest,
-        createEffectRequestContext
-    };
-};
-export { createGeneratedEffectClient };
+export * from "@modern-js/bff-effect/effect-client-runtime";

package/dist/esm/runtime/hono/adapter.mjs

@@ -1,7 +1,7 @@
+import { resolveAdapterCrossProjectPolicy } from "@modern-js/plugin-bff-extensions/cross-project-policy";
+import { bindHonoRouteHandlers } from "@modern-js/plugin-bff-extensions/hono";
 import { logger } from "@modern-js/utils";
 import createHonoRoutes from "../../utils/createHonoRoutes.mjs";
-import { checkCrossProjectPolicyResponse, resolveAdapterCrossProjectPolicy } from "../../utils/crossProjectServerPolicy.mjs";
-import { createSafeFailureResponse } from "../safe-failure.mjs";
 const before = [
     'custom-server-hook',
     'custom-server-middleware',
@@ -11,78 +11,37 @@ class HonoAdapter {
     constructor(api){
         this.apiMiddleware = [];
         this.isHono = true;
-        this.prefix = '/api';
         this.setHandlers = async ()=>{
             if (!this.isHono) return;
             const { apiHandlerInfos } = this.api.getServerContext();
-            const honoHandlers = createHonoRoutes(apiHandlerInfos);
+            const handlers = apiHandlerInfos ?? [];
+            const honoHandlers = createHonoRoutes(handlers);
+            const policy = resolveAdapterCrossProjectPolicy(this.api, handlers);
             this.apiMiddleware = honoHandlers.map(({ path, method, handler })=>({
                     name: 'hono-bff-api',
                     path,
                     method,
-                    handler: this.withErrorBoundary(handler),
+                    handler: bindHonoRouteHandlers({
+                        handler,
+                        policy,
+                        routePath: path,
+                        onError: this.api.getServerConfig()?.onError,
+                        reportError: (error)=>logger.error(error)
+                    }),
                     order: 'post',
                     before: before
                 }));
-            this.crossProjectPolicy = resolveAdapterCrossProjectPolicy(this.api, apiHandlerInfos || []);
-            if (this.crossProjectPolicy) {
-                const policyMiddleware = async (c, next)=>{
-                    const denial = checkCrossProjectPolicyResponse(c.req.header(), this.crossProjectPolicy);
-                    if (denial) return denial;
-                    await next();
-                };
-                this.apiMiddleware.unshift({
-                    name: 'bff-cross-project-policy',
-                    path: `${this.prefix}/*`,
-                    method: 'all',
-                    handler: policyMiddleware,
-                    order: 'post',
-                    before: before
-                });
-            }
         };
-        this.registerMiddleware = async (options = {})=>{
+        this.registerMiddleware = async (_options)=>{
             const { bffRuntimeFramework } = this.api.getServerContext();
             if ('hono' !== bffRuntimeFramework) {
                 this.isHono = false;
                 return;
             }
-            const { prefix } = options;
-            this.prefix = prefix || this.prefix;
             const { middlewares: globalMiddlewares } = this.api.getServerContext();
             await this.setHandlers();
             globalMiddlewares.push(...this.apiMiddleware);
         };
-        this.handleRouteError = async (error, c)=>{
-            try {
-                const onErrorHandler = this.api.getServerConfig()?.onError;
-                if (onErrorHandler) {
-                    const result = await onErrorHandler(error, c);
-                    if (result instanceof Response) return result;
-                } else logger.error(error);
-            } catch (configError) {
-                logger.error(`Error in serverConfig.onError handler: ${configError}`);
-            }
-            return createSafeFailureResponse(error);
-        };
-        this.withErrorBoundary = (handler)=>{
-            const handlers = Array.isArray(handler) ? handler : [
-                handler
-            ];
-            const [firstHandler, ...restHandlers] = handlers;
-            if (!firstHandler) return handler;
-            const boundary = async (c, next)=>{
-                try {
-                    return await firstHandler(c, next);
-                } catch (error) {
-                    return this.handleRouteError(error, c);
-                }
-            };
-            return Array.isArray(handler) ? [
-                boundary,
-                ...restHandlers
-            ] : boundary;
-        };
         this.api = api;
     }
 }

package/dist/esm/server.mjs

@@ -7,7 +7,7 @@ const RUNTIME_ADAPTER_LOADERS = {
             new HonoAdapter(api)
         ],
     effect: async (api)=>{
-        const { EffectAdapter } = await import("./runtime/effect/adapter.mjs");
+        const { EffectAdapter } = await import("@modern-js/plugin-bff-extensions/effect-adapter");
         return [
             new EffectAdapter(api)
         ];
@@ -82,7 +82,7 @@ const server = ()=>({
                 }
                 const runtimeAdapters = await RUNTIME_ADAPTER_LOADERS[runtimeFramework](api);
                 await Promise.all(runtimeAdapters.map((adapter)=>adapter.registerMiddleware({
-                        prefix,
+                        prefix: 'effect' === runtimeFramework ? prefixList : prefix,
                         enableHandleWeb
                     })));
             });

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

@@ -1,7 +1,6 @@
 import { generateClient } from "@modern-js/bff-core";
 import { fs, logger } from "@modern-js/utils";
 import path from "path";
-import { generateEffectClient, resolveEffectEntryFile } from "../effectClientGenerator.mjs";
 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";
@@ -14,6 +13,7 @@ async function clientGenerator(draftOptions) {
     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);
@@ -49,6 +49,7 @@ async function clientGenerator(draftOptions) {
             }
         }
         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,
@@ -63,21 +64,22 @@ async function clientGenerator(draftOptions) {
                     source: effectSource,
                     relativeDistPath: draftOptions.relativeDistPath
                 });
-                const effectClientArtifacts = await generateEffectClient({
+                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 (effectClientArtifacts) {
+                if (generatedEffectClient) {
                     const targetTypeFile = effectFileDetails.targetDir.replace(/\.js$/, '.d.ts');
-                    await writeTargetFile(effectFileDetails.absTargetDir, effectClientArtifacts.code);
-                    await writeTargetFile(path.resolve(targetTypeFile), effectClientArtifacts.declaration);
+                    await writeTargetFile(effectFileDetails.absTargetDir, generatedEffectClient.code);
+                    await writeTargetFile(path.resolve(targetTypeFile), generatedEffectClient.declaration);
                     generatedSourceList.push(effectFileDetails);
                 }
             }
@@ -89,6 +91,7 @@ async function clientGenerator(draftOptions) {
     }
     if (generatedSourceList.length > 0) await writeClientModuleBoundary(draftOptions.appDir, draftOptions.relativeDistPath);
     await setPackage(generatedSourceList, draftOptions.appDir, draftOptions.relativeDistPath);
+    return generatedEffectClient;
 }
 const generate = clientGenerator;
 export default generate;

package/dist/esm/utils/crossProjectApiPlugin.mjs

@@ -1,5 +1,6 @@
 import path from "path";
 const PACKAGE_NAME = '{packageName}';
+const REQUEST_ID = '{requestId}';
 const PREFIX = '{prefix}';
 const API_DIR = '{apiDirectory}';
 const LAMBDA_DIR = '{lambdaDirectory}';
@@ -42,7 +43,7 @@ const crossProjectApiPlugin = ()=>({
                     entry: effectEntry
                 };
                 resolvedConfig.bff.isCrossProjectServer = true;
-                resolvedConfig.bff.requestId = resolvedConfig.bff.requestId || config?.bff?.requestId || PACKAGE_NAME || 'default';
+                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 || {},
@@ -64,4 +65,4 @@ const crossProjectApiPlugin = ()=>({
     });
 const utils_crossProjectApiPlugin = crossProjectApiPlugin;
 export default utils_crossProjectApiPlugin;
-export { API_DIR, DIST_DIR, EFFECT_ENTRY, LAMBDA_DIR, OPERATION_CONTRACTS_JSON, PACKAGE_NAME, PREFIX, RUNTIME_FRAMEWORK, crossProjectApiPlugin };
+export { API_DIR, DIST_DIR, EFFECT_ENTRY, LAMBDA_DIR, OPERATION_CONTRACTS_JSON, PACKAGE_NAME, PREFIX, REQUEST_ID, RUNTIME_FRAMEWORK, crossProjectApiPlugin };

package/dist/esm/utils/pluginGenerator.mjs

@@ -1,18 +1,18 @@
 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, RUNTIME_FRAMEWORK } from "./crossProjectApiPlugin.mjs";
-function replaceContent(source, packageName, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts) {
-    const updatedSource = source.replace(new RegExp(PACKAGE_NAME, 'g'), packageName).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)));
+import { API_DIR, DIST_DIR, EFFECT_ENTRY, LAMBDA_DIR, OPERATION_CONTRACTS_JSON, PACKAGE_NAME, PREFIX, REQUEST_ID, RUNTIME_FRAMEWORK } from "./crossProjectApiPlugin.mjs";
+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 pluginGenerator({ prefix, appDirectory, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts }) {
+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(__dirname, 'crossProjectApiPlugin.js'), 'utf8');
-        const updatedPlugin = replaceContent(pluginTemplate, packageJson.name, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts);
+        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';

package/dist/esm/utils/runtimeGenerator.mjs

@@ -1,3 +1,4 @@
+import { renderProducerRuntimeDefaults } from "@modern-js/plugin-bff-extensions/cross-project-generation";
 import { fs } from "@modern-js/utils";
 import path from "path";
 const getPackageName = (appDirectory)=>{
@@ -14,21 +15,8 @@ async function runtimeGenerator({ runtime, appDirectory, relativeDistPath, packa
     const requestId = packageName || getPackageName(appDirectory) || process.env.npm_package_name || 'default';
     const runtimeImportPath = JSON.stringify(runtime);
     const requestIdValue = JSON.stringify(requestId);
-    const source = `const { configure: _configure } = require(${runtimeImportPath});
-    const defaultSecureOptions = {
-      requestId: ${requestIdValue},
-      requireEnvelope: true,
-      identityBinding: {
-        enabled: true,
-        strict: true,
-      },
-      operationContract: {
-        enabled: true,
-        strict: true,
-        requireSchemaHash: true,
-        requireOperationVersion: true,
-      },
-    };
+    const source = `'use strict'; const { configure: _configure } = require(${runtimeImportPath});
+    const defaultSecureOptions = ${renderProducerRuntimeDefaults(requestIdValue)};
     const initProducerClient = (options) => {
       return _configure({
         ...defaultSecureOptions,
@@ -79,7 +67,7 @@ async function runtimeGenerator({ runtime, appDirectory, relativeDistPath, packa
         }) => string;
         requestId?: string;
       };
-  export declare const initProducerClient: (options: ProducerClientOptions) => void;
+  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);

package/dist/esm-node/cli/generator.mjs

@@ -3,33 +3,11 @@ import { ApiRouter, buildOperationContractMap, deriveOperationVersion } from "@m
 import { compile } from "@modern-js/server-utils";
 import { API_DIR, SHARED_DIR, fs, resolveServerTsconfig, upath } from "@modern-js/utils";
 import clientGenerator from "../utils/clientGenerator.mjs";
-import { bundleEffectEntryForNode } from "../utils/effectSourceLoader.mjs";
 import pluginGenerator from "../utils/pluginGenerator.mjs";
 import runtimeGenerator from "../utils/runtimeGenerator.mjs";
 import { getPrimaryPrefix } from "./prefix.mjs";
 import { serializeServerGlobalVars, transformServerGlobalVars } from "./serverGlobalVars.mjs";
 const RUNTIME_CREATE_REQUEST = '@modern-js/plugin-bff/client';
-const effectEntryExtensions = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.mjs',
-    '.mts',
-    '.cjs',
-    '.cts'
-];
-function resolveEffectSourceEntry(appDirectory, apiDirectory, configuredEntry) {
-    const entry = void 0 !== configuredEntry && configuredEntry.length > 0 ? upath.isAbsolute(configuredEntry) ? configuredEntry : upath.resolve(appDirectory, configuredEntry) : upath.resolve(apiDirectory, 'index');
-    return upath.extname(entry).length > 0 ? entry : effectEntryExtensions.map((extension)=>`${entry}${extension}`).find((candidate)=>fs.existsSync(candidate));
-}
-function resolveBuiltEffectEntry(appDirectory, distDirectory, sourceEntry) {
-    if (void 0 === sourceEntry || 0 === sourceEntry.length) return;
-    const relativeEntry = upath.relative(appDirectory, sourceEntry);
-    if ('..' === relativeEntry || relativeEntry.startsWith(`..${upath.sep}`)) throw new Error(`Effect BFF entry must be inside the application directory: ${sourceEntry}`);
-    const builtEntry = upath.resolve(distDirectory, relativeEntry).replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js');
-    return fs.existsSync(builtEntry) ? builtEntry : void 0;
-}
 const createBffGenerator = (api)=>{
     const compileApi = ()=>Promise.resolve().then(()=>{
             const { appDirectory, distDirectory, apiDirectory, bffRuntimeFramework, sharedDirectory, moduleType } = api.getAppContext();
@@ -57,20 +35,20 @@ const createBffGenerator = (api)=>{
                     tsconfigPath,
                     moduleType,
                     throwErrorInsteadOfExit: true
-                }).then(()=>transformServerGlobalVars(sourceDirs.map((sourceDir)=>upath.resolve(distDir, upath.relative(appDirectory, sourceDir))), serializedGlobalVars)).then(()=>{
+                }).then(()=>transformServerGlobalVars(sourceDirs.map((sourceDir)=>upath.resolve(distDir, upath.relative(appDirectory, sourceDir))), serializedGlobalVars)).then(async ()=>{
                     if ('effect' !== bffRuntimeFramework) return;
-                    const sourceEntry = resolveEffectSourceEntry(appDirectory, apiDir, modernConfig.bff?.effect?.entry);
-                    const builtEntry = resolveBuiltEffectEntry(appDirectory, distDir, sourceEntry);
-                    if (void 0 === builtEntry || 0 === builtEntry.length) throw new Error(`Effect BFF entry was not emitted into ${distDir}: ${sourceEntry ?? upath.resolve(apiDir, 'index')}`);
-                    return bundleEffectEntryForNode({
+                    const { bundleBuiltEffectEntryForNode } = await import("@modern-js/plugin-bff-extensions/client-generator");
+                    return bundleBuiltEffectEntryForNode({
                         appDir: appDirectory,
-                        entryPath: builtEntry,
+                        apiDir,
+                        distDir,
+                        effectEntry: modernConfig.bff?.effect?.entry,
                         format: 'module' === moduleType ? 'esm' : 'cjs'
                     });
                 });
             });
         });
-    const generate = ()=>Promise.resolve().then(()=>{
+    const generate = ()=>Promise.resolve().then(async ()=>{
             const { appDirectory, apiDirectory, lambdaDirectory, port, bffRuntimeFramework, packageName } = api.getAppContext();
             const modernConfig = api.getNormalizedConfig();
             const relativeDistPath = modernConfig?.output?.distPath?.root || 'dist';
@@ -88,43 +66,57 @@ const createBffGenerator = (api)=>{
             const lambdaDir = apiRouter.getLambdaDir();
             const existLambda = apiRouter.isExistLambda();
             const packageJson = fs.readJSONSync(upath.resolve(appDirectory, 'package.json'));
-            const requestId = packageJson.name || packageName;
-            const operationContractsPromise = existLambda ? apiRouter.getApiHandlers().then((handlers)=>buildOperationContractMap({
+            const requestId = bff?.requestId || packageJson.name || packageName || 'default';
+            const operationContractsPromise = 'effect' !== bffRuntimeFramework && existLambda ? apiRouter.getApiHandlers().then((handlers)=>buildOperationContractMap({
                     handlers,
                     requestId,
                     operationVersion: deriveOperationVersion(packageJson.version)
                 })) : Promise.resolve({});
-            return operationContractsPromise.then((operationContracts)=>{
-                const runtime = bff?.runtimeCreateRequest || RUNTIME_CREATE_REQUEST;
-                const relativeApiPath = upath.relative(appDirectory, apiDirectory);
-                const relativeLambdaPath = upath.relative(appDirectory, lambdaDir);
-                const sourceEffectEntry = 'effect' === bffRuntimeFramework ? resolveEffectSourceEntry(appDirectory, apiDirectory, bff?.effect?.entry) : void 0;
-                const relativeEffectEntry = void 0 !== sourceEffectEntry && sourceEffectEntry.length > 0 ? upath.relative(appDirectory, sourceEffectEntry).replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js') : '';
+            const runtime = bff?.runtimeCreateRequest || RUNTIME_CREATE_REQUEST;
+            const relativeApiPath = upath.relative(appDirectory, apiDirectory);
+            const relativeLambdaPath = upath.relative(appDirectory, lambdaDir);
+            const { sourceEffectEntry, relativeEffectEntry } = 'effect' === bffRuntimeFramework ? (await import("@modern-js/plugin-bff-extensions/client-generator")).resolveEffectEntryPaths({
+                appDir: appDirectory,
+                apiDir: apiDirectory,
+                effectEntry: bff?.effect?.entry
+            }) : {
+                sourceEffectEntry: void 0,
+                relativeEffectEntry: ''
+            };
+            const clientGenerationPromise = clientGenerator({
+                prefix,
+                appDir: appDirectory,
+                apiDir: apiDirectory,
+                lambdaDir,
+                existLambda,
+                port,
+                requestId,
+                requestCreator: bff?.requestCreator,
+                httpMethodDecider,
+                relativeDistPath,
+                relativeApiPath,
+                apiFiles: apiRouter.getApiFiles(),
+                bffRuntimeFramework,
+                effectEntry: bff?.effect?.entry,
+                effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch
+            });
+            return Promise.all([
+                operationContractsPromise,
+                clientGenerationPromise
+            ]).then(([lambdaContracts, generatedEffectClient])=>{
+                if ('effect' === bffRuntimeFramework && null === generatedEffectClient) throw new Error(`Effect cross-project client generation failed for ${sourceEffectEntry ?? apiDirectory}.`);
+                const operationContracts = 'effect' === bffRuntimeFramework ? generatedEffectClient?.operationContracts ?? {} : lambdaContracts;
                 return pluginGenerator({
                     prefix,
                     appDirectory,
+                    requestId,
                     relativeDistPath,
                     relativeApiPath,
                     relativeLambdaPath,
                     runtimeFramework: 'hono' === bffRuntimeFramework ? 'hono' : 'effect',
                     relativeEffectEntry,
                     operationContracts
-                }).then(()=>clientGenerator({
-                        prefix,
-                        appDir: appDirectory,
-                        apiDir: apiDirectory,
-                        lambdaDir,
-                        existLambda,
-                        port,
-                        requestCreator: bff?.requestCreator,
-                        httpMethodDecider,
-                        relativeDistPath,
-                        relativeApiPath,
-                        apiFiles: apiRouter.getApiFiles(),
-                        bffRuntimeFramework,
-                        effectEntry: bff?.effect?.entry,
-                        effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch
-                    })).then(()=>runtimeGenerator({
+                }).then(()=>runtimeGenerator({
                         runtime,
                         appDirectory,
                         relativeDistPath

package/dist/esm-node/cli/serverGlobalVars.mjs

@@ -54,7 +54,7 @@ const transformServerGlobalVars = (outputDirectories, globalVars)=>Promise.resol
                                             syntax: "ecmascript"
                                         },
                                         preserveAllComments: true,
-                                        target: 'es2022',
+                                        target: 'es2024',
                                         transform: {
                                             optimizer: {
                                                 globals: {

package/dist/esm-node/cli.mjs

@@ -62,6 +62,7 @@ const bffPlugin = ()=>({
                                 lambdaDir,
                                 existLambda,
                                 port,
+                                requestId: bff?.requestId,
                                 target: name,
                                 requestCreator: bff?.requestCreator,
                                 httpMethodDecider,