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

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,

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
                     })));
             });