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

package/dist/esm-node/loader.mjs

@@ -1,9 +1,9 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
 import { generateClient } from "@modern-js/bff-core";
+import { generateEffectClientCode, generateEffectWorkerRuntimeWrapper, resolveEffectEntryFile } from "@modern-js/plugin-bff-extensions/effect-source-loader";
 import { logger } from "@modern-js/utils";
 import path from "path";
-import { generateEffectClientCode, resolveEffectEntryFile } from "./utils/effectClientGenerator.mjs";
 const EFFECT_BFF_WORKER_RUNTIME_QUERY = 'modern-bff-runtime';
 const EFFECT_BFF_WORKER_RUNTIME_SOURCE_QUERY = 'modern-bff-runtime-source';
 const createErrorModule = (message)=>`throw new Error(${JSON.stringify(message)});`;
@@ -17,7 +17,7 @@ async function transformEffectRuntimeSource(source, filename) {
                 syntax: "typescript",
                 tsx: filename.endsWith('.tsx') || filename.endsWith('.jsx')
             },
-            target: 'es2022'
+            target: 'es2024'
         },
         module: {
             type: 'es6'
@@ -25,18 +25,6 @@ async function transformEffectRuntimeSource(source, filename) {
     });
     return result.code;
 }
-function createEffectWorkerRuntimeWrapper(resourcePath) {
-    const sourceRequest = `${resourcePath}?${EFFECT_BFF_WORKER_RUNTIME_SOURCE_QUERY}`;
-    return `import * as effectBffModule from ${JSON.stringify(sourceRequest)};
-import { createEffectBffEdgeDispatcher } from '@modern-js/plugin-bff/effect-edge/dispatcher';
-
-export const __modern_create_effect_bff_dispatcher = options =>
-  createEffectBffEdgeDispatcher({
-    ...options,
-    module: effectBffModule,
-  });
-`;
-}
 async function loader(source) {
     this.cacheable();
     const { resourcePath } = this;
@@ -54,7 +42,7 @@ async function loader(source) {
         callback(void 0, code);
         return;
     }
-    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && path.resolve(effectEntryFile) === path.resolve(resourcePath) && resourceQueries.has(EFFECT_BFF_WORKER_RUNTIME_QUERY)) return void callback(void 0, createEffectWorkerRuntimeWrapper(resourcePath));
+    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && path.resolve(effectEntryFile) === path.resolve(resourcePath) && resourceQueries.has(EFFECT_BFF_WORKER_RUNTIME_QUERY)) return void callback(void 0, await generateEffectWorkerRuntimeWrapper(this, draftOptions, resourcePath));
     if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && path.resolve(effectEntryFile) === path.resolve(resourcePath)) {
         const code = await generateEffectClientCode({
             appDir: draftOptions.appDir,
@@ -63,13 +51,14 @@ async function loader(source) {
             prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
             port: Number(draftOptions.port),
             target: draftOptions.target,
+            requestId: draftOptions.requestId,
             requestCreator: draftOptions.requestCreator,
             httpMethodDecider: draftOptions.httpMethodDecider,
             dataPlatformBatch: draftOptions.effectDataPlatformBatch,
             onDependency: (dependency)=>this.addDependency(dependency)
         });
         if (code) return void callback(void 0, code);
-        callback(void 0, createErrorModule(`Failed to generate Effect client for ${resourcePath}`));
+        callback(new Error(`Failed to generate Effect client for ${resourcePath}`));
         return;
     }
     const warning = `The file ${resourcePath} is not allowed to be imported in src directory, only API definition files are allowed.`;

package/dist/esm-node/runtime/data-platform/index.mjs

@@ -1,8 +1,2 @@
 import "node:module";
-export { measureTextBytes, normalizeMethod } from "./batch/request.mjs";
-export { DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransport, createDataBatchTransportTelemetryAttributes, emitDataBatchTransportEvent } from "./batch-transport.mjs";
-export { buildQueryKey, buildScopeKey, createOperationId, decodeRequestEnvelopeHeader, encodeRequestEnvelopeHeader, isPlainObject, normalizeOrigin, stableStringify } from "./codec.mjs";
-export { createInvalidationEvent, shouldApplyInvalidation } from "./invalidation.mjs";
-export { deriveChildTraceContext, formatTraceparentHeader, parseTraceparentHeader } from "./trace.mjs";
-export { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER } from "./types.mjs";
-export { createHydrationEnvelope, createRequestEnvelope, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan } from "./validation.mjs";
+export * from "@modern-js/bff-effect/data-platform";

package/dist/esm-node/runtime/effect/edge-dispatcher.mjs

@@ -1,39 +1,2 @@
 import "node:module";
-import { dispatchEffectBffRequestWithContext } from "./dispatch.mjs";
-import { runWithEffectContext, useEffectContext, useOperationContext } from "./edge-context.mjs";
-import { resolveEffectBffModuleHandler } from "./module.mjs";
-export * from "./handler.mjs";
-async function dispatchEffectBffRequest(handler, request, options = {}) {
-    return dispatchEffectBffRequestWithContext(handler, request, {
-        ...options,
-        runWithEffectContext: runWithEffectContext
-    });
-}
-async function createEffectBffEdgeDispatcher(options) {
-    const loaded = await resolveEffectBffModuleHandler(options.module, {
-        openapi: options.openapi,
-        dataPlatform: options.dataPlatform,
-        onWarning: options.onWarning
-    });
-    if (!loaded) throw new Error('[BFF][Effect] Invalid Effect edge module. Export defineEffectBff(...) or a { api, layer } HttpApi module.');
-    return {
-        dispatch: (request, dispatchOptions = {})=>dispatchEffectBffRequest(loaded.handler, request, {
-                ...dispatchOptions,
-                prefix: options.prefix,
-                onError: options.onError
-            }),
-        dispose: async ()=>{
-            await loaded.dispose?.();
-        }
-    };
-}
-const createEffectBffTestHandler = createEffectBffEdgeHandler;
-async function createEffectBffEdgeHandler(options) {
-    const dispatcher = await createEffectBffEdgeDispatcher(options);
-    return {
-        handler: dispatcher.dispatch,
-        dispose: dispatcher.dispose
-    };
-}
-export { createEffectOperationContext } from "./operation-context.mjs";
-export { createEffectBffEdgeDispatcher, createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest, runWithEffectContext, useEffectContext, useOperationContext };
+export * from "@modern-js/bff-effect/effect-edge";

package/dist/esm-node/runtime/effect/edge.mjs

@@ -1,3 +1,3 @@
 import "node:module";
-export * from "./edge-dispatcher.mjs";
-export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, loadBackendFederatedEffectApi, validateExpectedBackendFederationIdentity } from "./backend-federation.mjs";
+export * from "@modern-js/bff-effect/effect-edge";
+export * from "@modern-js/plugin-bff-extensions/backend-federation/edge";

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

@@ -1,9 +1,17 @@
 import "node:module";
-import * as __rspack_external__effect_opentelemetry_66324c75 from "@effect/opentelemetry";
-export * from "./backend-federation.mjs";
-export * from "./handler.mjs";
-export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, loadBackendFederatedEffectApi } from "./backend-federation.mjs";
-export { BackendFederationManifestAdapterError, loadBackendFederatedEffectApiFromManifest, loadBackendFederationManifest, resolveBackendFederationRemoteFromManifest } from "./backend-federation-manifest.mjs";
-export { createEffectOperationContext, runWithEffectContext, useEffectContext, useOperationContext } from "./context.mjs";
-export { createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest } from "./edge.mjs";
-export { __rspack_external__effect_opentelemetry_66324c75 as OpenTelemetry };
+import * as __rspack_external_effect_Config_76cfa59d from "effect/Config";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
+import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
+import * as __rspack_external_effect_Option_0498e63a from "effect/Option";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
+export * from "effect/unstable/http";
+export * from "effect/unstable/httpapi";
+export * from "effect/unstable/rpc";
+export { OpenTelemetry, createEffectBffEdgeHandler, createEffectBffTestHandler, createEffectOperationContext, createHttpApiHandler, defineEffectBff, defineEffectRpcBff, dispatchEffectBffRequest, runWithEffectContext, useEffectContext, useOperationContext } from "@modern-js/bff-effect/effect";
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, validateExpectedBackendFederationIdentity } from "@modern-js/plugin-bff-extensions/backend-federation";
+export { loadBackendFederatedEffectApi } from "@modern-js/plugin-bff-extensions/backend-federation/node";
+export { BackendFederationManifestAdapterError, loadBackendFederationManifest, resolveBackendFederationRemoteFromManifest } from "@modern-js/plugin-bff-extensions/backend-federation-manifest";
+export { loadBackendFederatedEffectApiFromManifest } from "@modern-js/plugin-bff-extensions/backend-federation-manifest/node";
+export { HttpTraceContext } from "effect/unstable/http";
+export { HttpApiBuilder } from "effect/unstable/httpapi";
+export { __rspack_external_effect_Config_76cfa59d as Config, __rspack_external_effect_Effect_41060786 as Effect, __rspack_external_effect_Layer_69c46453 as Layer, __rspack_external_effect_Option_0498e63a as Option, __rspack_external_effect_Schema_6065f72d as Schema };

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

@@ -1,99 +1,2 @@
 import "node:module";
-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-node/runtime/effect-client/runtime.mjs

@@ -1,63 +1,2 @@
 import "node:module";
-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-node/runtime/hono/adapter.mjs

@@ -1,8 +1,8 @@
 import "node:module";
+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',
@@ -12,78 +12,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-node/server.mjs

@@ -8,7 +8,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)
         ];
@@ -83,7 +83,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-node/utils/client-generator/generate.mjs

@@ -2,7 +2,6 @@ import "node:module";
 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";
@@ -15,6 +14,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);
@@ -50,6 +50,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,
@@ -64,21 +65,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);
                 }
             }
@@ -90,6 +92,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-node/utils/crossProjectApiPlugin.mjs

@@ -1,6 +1,7 @@
 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}';
@@ -43,7 +44,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 || {},
@@ -65,4 +66,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-node/utils/pluginGenerator.mjs

@@ -1,22 +1,22 @@
 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, RUNTIME_FRAMEWORK } from "./crossProjectApiPlugin.mjs";
+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, 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)));
+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(__rspack_import_meta_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-node/utils/runtimeGenerator.mjs

@@ -1,5 +1,6 @@
 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 { fs } from "@modern-js/utils";
 import path from "path";
 const getPackageName = (appDirectory)=>{
@@ -16,21 +17,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,
@@ -81,7 +69,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/types/loader.d.ts

@@ -9,6 +9,7 @@ export type APILoaderOptions = {
     port: number;
     fetcher?: string;
     requestCreator?: string;
+    requestId?: string;
     target: string;
     httpMethodDecider?: HttpMethodDecider;
     bffRuntimeFramework?: 'hono' | 'effect';

package/dist/types/runtime/data-platform/index.d.ts

@@ -1,8 +1 @@
-export { measureTextBytes, normalizeMethod } from './batch/request';
-export { createDataBatchTransport, createDataBatchTransportTelemetryAttributes, DATA_BATCH_TRANSPORT_OTEL_EVENT, emitDataBatchTransportEvent, } from './batch-transport';
-export { buildQueryKey, buildScopeKey, createOperationId, decodeRequestEnvelopeHeader, encodeRequestEnvelopeHeader, isPlainObject, normalizeOrigin, stableStringify, } from './codec';
-export { createInvalidationEvent, shouldApplyInvalidation, } from './invalidation';
-export { deriveChildTraceContext, formatTraceparentHeader, parseTraceparentHeader, } from './trace';
-export type { CacheScope, DataBatchRequestItem, DataBatchRequestPayload, DataBatchResponseItem, DataBatchResponsePayload, DataBatchTransportEvent, DataBatchTransportOptions, DataBatchTransportTelemetryAttributes, DataMutationMode, DataRequestMode, HydrationEnvelope, HydrationEnvelopeValidationOptions, InvalidationEvent, InvalidationSubscriber, OperationDescriptor, RequestEnvelope, RequestEnvelopeValidationOptions, SelectionPlan, SelectionPlanValidationOptions, SelectionPlanValidationResult, TraceContext, } from './types';
-export { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, } from './types';
-export { createHydrationEnvelope, createRequestEnvelope, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan, } from './validation';
+export * from '@modern-js/bff-effect/data-platform';

package/dist/types/runtime/effect/edge-dispatcher.d.ts

@@ -1,26 +1 @@
-import { type DispatchEffectBffRequestOptions } from './dispatch';
-import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions } from './handler';
-import { type EffectApiModule, type EffectBffRequestHandler } from './module';
-import type { EffectContext } from './operation-context';
-export { runWithEffectContext, useEffectContext, useOperationContext, } from './edge-context';
-export * from './handler';
-export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context';
-export type EffectBffEdgeDispatchOptions = Omit<DispatchEffectBffRequestOptions, 'runWithEffectContext'>;
-export type EffectBffEdgeHandlerOptions = {
-    module: EffectApiModule;
-    prefix?: string;
-    openapi?: EffectBffOpenApiConfig;
-    dataPlatform?: EffectDataPlatformValidationOptions;
-    onError?: (error: unknown, context: EffectContext) => Promise<Response> | Response;
-    onWarning?: (message: string) => void;
-};
-export declare function dispatchEffectBffRequest(handler: EffectBffRequestHandler, request: Request, options?: EffectBffEdgeDispatchOptions): Promise<Response>;
-export declare function createEffectBffEdgeDispatcher(options: EffectBffEdgeHandlerOptions): Promise<{
-    dispatch: (request: Request, dispatchOptions?: Omit<EffectBffEdgeDispatchOptions, 'prefix' | 'onError'>) => Promise<Response>;
-    dispose: () => Promise<void>;
-}>;
-export declare const createEffectBffTestHandler: typeof createEffectBffEdgeHandler;
-export declare function createEffectBffEdgeHandler(options: EffectBffEdgeHandlerOptions): Promise<{
-    handler: (request: Request, dispatchOptions?: Omit<EffectBffEdgeDispatchOptions, 'prefix' | 'onError'>) => Promise<Response>;
-    dispose: () => Promise<void>;
-}>;
+export * from '@modern-js/bff-effect/effect-edge';