@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.98 → 3.8.1-ultramodern.1

package/dist/esm/runtime/effect/adapter/entry.mjs

@@ -22,23 +22,31 @@ function relativeAppPath(appDirectory, entryPath) {
     const relativePath = path.relative(appDirectory, entryPath);
     return '..' === relativePath || relativePath.startsWith(`..${path.sep}`) ? void 0 : relativePath;
 }
+function isDependencyPath(relativePath) {
+    return relativePath?.split(/[\\/]/u).includes('node_modules') ?? false;
+}
 function resolveEffectAdapterEntryFile(api) {
     const { appDirectory, apiDirectory, distDirectory } = api.getServerContext();
     const appRoot = path.resolve(appDirectory || process.cwd());
-    const productionRoot = isProd() && distDirectory ? distDirectory : void 0;
+    const productionRoot = isProd() && distDirectory ? path.resolve(distDirectory) : void 0;
     const bffConfig = api.getServerConfig()?.bff;
     const configuredEntry = bffConfig?.effect?.entry;
     if (configuredEntry) {
         const sourceEntry = path.isAbsolute(configuredEntry) ? configuredEntry : path.resolve(appRoot, configuredEntry);
         if (productionRoot) {
             const relativeEntry = relativeAppPath(appRoot, sourceEntry);
+            if (void 0 === relativeEntry || isDependencyPath(relativeEntry)) return resolveJsOrTsEntry(sourceEntry);
             return relativeEntry ? resolveJsOrTsEntry(builtEntryPath(path.resolve(productionRoot, relativeEntry))) : void 0;
         }
         return resolveJsOrTsEntry(sourceEntry);
     }
-    const relativeApiDirectory = apiDirectory ? path.isAbsolute(apiDirectory) ? relativeAppPath(appRoot, apiDirectory) : apiDirectory : API_DIR;
-    if (!relativeApiDirectory) return;
-    const apiRoot = path.resolve(productionRoot || appRoot, relativeApiDirectory);
-    return resolveJsOrTsEntry(path.resolve(apiRoot, 'index'));
+    const resolvedApiDirectory = path.resolve(appRoot, apiDirectory || API_DIR);
+    const productionApiDirectory = productionRoot ? void 0 !== relativeAppPath(productionRoot, resolvedApiDirectory) ? resolvedApiDirectory : (()=>{
+        const relativeApiDirectory = relativeAppPath(appRoot, resolvedApiDirectory);
+        if (isDependencyPath(relativeApiDirectory)) return resolvedApiDirectory;
+        return relativeApiDirectory ? path.resolve(productionRoot, relativeApiDirectory) : void 0;
+    })() : resolvedApiDirectory;
+    if (!productionApiDirectory) return;
+    return resolveJsOrTsEntry(path.resolve(productionApiDirectory, 'index'));
 }
 export { resolveEffectAdapterEntryFile };

package/dist/esm/runtime/effect/adapter/error-response.mjs

@@ -1,22 +1,24 @@
 import { logger } from "@modern-js/utils";
 import { createSafeFailureResponse } from "../../safe-failure.mjs";
-async function createEffectAdapterRuntimeErrorResponse(api, error, c) {
+function createEffectAdapterRuntimeErrorResponse(api, error, c) {
     try {
         const serverConfig = api.getServerConfig();
         const onErrorHandler = serverConfig?.onError;
-        if (onErrorHandler) {
+        if (void 0 !== onErrorHandler) {
             const onErrorContext = ensureJsonContext(c);
-            const result = await onErrorHandler(error instanceof Error ? error : new Error(String(error)), onErrorContext);
-            if (result instanceof Response) return result;
-        } else logger.error(error);
+            return Promise.resolve(onErrorHandler(error instanceof Error ? error : new Error(String(error)), onErrorContext)).then((result)=>result instanceof Response ? result : createSafeFailureResponse(error)).catch((configError)=>{
+                logger.error(`Error in serverConfig.onError handler: ${String(configError)}`);
+                return createSafeFailureResponse(error);
+            });
+        }
+        logger.error(error instanceof Error ? error : new Error(String(error)));
     } catch (configError) {
         logger.error(`Error in serverConfig.onError handler: ${configError}`);
     }
-    return createSafeFailureResponse(error);
+    return Promise.resolve(createSafeFailureResponse(error));
 }
 function ensureJsonContext(c) {
-    const maybeJsonContext = c;
-    if ('function' == typeof maybeJsonContext.json) return c;
+    if ('json' in c && 'function' == typeof c.json) return c;
     const headers = {
         'content-type': 'application/json; charset=utf-8'
     };
@@ -27,7 +29,7 @@ function ensureJsonContext(c) {
                 headers: extraHeaders
             } : statusOrInit;
             const responseHeaders = new Headers(headers);
-            if (responseInit.headers) new Headers(responseInit.headers).forEach((value, key)=>{
+            if (void 0 !== responseInit.headers) new Headers(responseInit.headers).forEach((value, key)=>{
                 responseHeaders.set(key, value);
             });
             return new Response(JSON.stringify(data), {

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

@@ -1,6 +1,6 @@
 import { fs, isProd, logger } from "@modern-js/utils";
 import path from "path";
-import { loadEffectSourceModule } from "../../utils/effectSourceLoader.mjs";
+import { loadEffectBuiltModule, loadEffectSourceModule } from "../../utils/effectSourceLoader.mjs";
 import { before } from "./adapter/constants.mjs";
 import { resolveEffectAdapterCrossProjectPolicy } from "./adapter/cross-project-policy.mjs";
 import { resolveEffectAdapterEntryFile } from "./adapter/entry.mjs";
@@ -29,10 +29,10 @@ class EffectAdapter {
         let mod;
         try {
             const { appDirectory } = this.api.getServerContext();
-            mod = await loadEffectSourceModule({
+            mod = await (isProd() ? loadEffectBuiltModule(entryFile) : loadEffectSourceModule({
                 resourcePath: entryFile,
                 appDir: appDirectory || path.dirname(entryFile)
-            });
+            }));
         } catch (error) {
             logger.error(`[BFF][Effect] Failed to load Effect entry: ${entryFile}\n${String(error)}`);
             this.handler = null;

package/dist/esm/runtime/effect/backend-federation/load.mjs

@@ -2,27 +2,36 @@ import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "@modern-js/utils/universal";
 import { formatBackendFederationIdentityIssues, validateExpectedBackendFederationIdentity } from "./identity.mjs";
 import { createBackendFederationRuntime } from "./runtime.mjs";
 import { isRecord, normalizeExpose } from "./utils.mjs";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
+import * as __rspack_external_effect_Logger_1691a01b from "effect/Logger";
 const LEGACY_LOAD_WARNING = '[BFF][Effect] loadBackendFederatedEffectApi was called without an expected delivery-unit identity (expected.unitId + expected.buildMarker). Identity-less public backend loads are deprecated (ADR-0019/MV-G23) and will be rejected in a future major.';
-async function loadBackendFederatedEffectApi(options) {
+const legacyWarningLogger = __rspack_external_effect_Logger_1691a01b.withLeveledConsole(__rspack_external_effect_Logger_1691a01b.formatLogFmt);
+function warnLegacyLoad() {
+    __rspack_external_effect_Effect_41060786.runSync(__rspack_external_effect_Effect_41060786.provideService(__rspack_external_effect_Effect_41060786.logWarning(LEGACY_LOAD_WARNING), __rspack_external_effect_Logger_1691a01b.CurrentLoggers, new Set([
+        legacyWarningLogger
+    ])));
+}
+function loadBackendFederatedEffectApi(options) {
     const remoteName = options.remote?.name ?? options.remoteName;
-    if (!remoteName) throw new Error('[BFF][Effect] Missing backend federation remote name.');
-    if (void 0 === options.expected) console.warn(LEGACY_LOAD_WARNING);
+    if (void 0 === remoteName || 0 === remoteName.length) return Promise.reject(new Error('[BFF][Effect] Missing backend federation remote name.'));
+    if (void 0 === options.expected) warnLegacyLoad();
     const runtime = options.runtime ?? createBackendFederationRuntime(options);
     const expose = options.expose ?? options.remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE;
     const remoteRequest = `${remoteName}/${normalizeExpose(expose)}`;
-    const loaded = await runtime.loadRemote(remoteRequest);
-    if (!isRecord(loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must load an object module.`);
-    const backendContract = loaded.backendFederationContract;
-    if (!isRecord(backendContract) || true !== backendContract.strictEffectApproach) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose strict Effect metadata (strictEffectApproach: true).`);
-    if ('effect' !== backendContract.runtimeFramework) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose strict Effect metadata (runtimeFramework: "effect").`);
-    if ('string' == typeof backendContract.name && backendContract.name !== remoteName) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} metadata name mismatch: expected ${remoteName}, received ${backendContract.name}.`);
-    if (!('runtime' in loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose api and runtime.`);
-    if (void 0 !== options.expected) {
-        const issues = validateExpectedBackendFederationIdentity(loaded, options.expected, {
-            allowMissingIdentityMetadata: true === options.allowMissingIdentityMetadata
-        });
-        if (issues.length > 0) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} delivery-unit identity mismatch: ${formatBackendFederationIdentityIssues(issues)}.`);
-    }
-    return loaded;
+    return runtime.loadRemote(remoteRequest).then((loaded)=>{
+        if (!isRecord(loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must load an object module.`);
+        const backendContract = loaded.backendFederationContract;
+        if (!isRecord(backendContract) || true !== backendContract.strictEffectApproach) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose strict Effect metadata (strictEffectApproach: true).`);
+        if ('effect' !== backendContract.runtimeFramework) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose strict Effect metadata (runtimeFramework: "effect").`);
+        if ('string' == typeof backendContract.name && backendContract.name !== remoteName) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} metadata name mismatch: expected ${remoteName}, received ${backendContract.name}.`);
+        if (!('runtime' in loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose api and runtime.`);
+        if (void 0 !== options.expected) {
+            const issues = validateExpectedBackendFederationIdentity(loaded, options.expected, {
+                allowMissingIdentityMetadata: true === options.allowMissingIdentityMetadata
+            });
+            if (issues.length > 0) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} delivery-unit identity mismatch: ${formatBackendFederationIdentityIssues(issues)}.`);
+        }
+        return loaded;
+    });
 }
 export { loadBackendFederatedEffectApi };

package/dist/esm/runtime/effect/backend-federation/plugin.mjs

@@ -1,13 +1,23 @@
 function createBackendFederationLoadEntryPlugin(options) {
     return {
         name: 'modernjs-backend-federation-load-entry',
-        async loadEntry ({ remoteInfo }) {
-            return options.resolveEntry({
+        loadEntry ({ remoteInfo }) {
+            return Promise.resolve(options.resolveEntry({
                 name: remoteInfo.name,
                 entry: remoteInfo.entry,
                 type: remoteInfo.type,
                 entryGlobalName: remoteInfo.entryGlobalName,
                 shareScope: remoteInfo.shareScope
+            })).then((entry)=>{
+                if (void 0 === entry) return;
+                return {
+                    get (id) {
+                        return ()=>Promise.resolve(entry.get(id)).then((factory)=>factory());
+                    },
+                    init (...args) {
+                        return entry.init?.(...args);
+                    }
+                };
             });
         }
     };

package/dist/esm/runtime/effect/backend-federation/remotes.mjs

@@ -2,10 +2,11 @@ function collectRemotes(options) {
     const remotes = [
         ...options.remotes ?? []
     ];
-    if (options.remote) {
-        const existingIndex = remotes.findIndex((remote)=>remote.name === options.remote?.name);
-        if (existingIndex >= 0) remotes[existingIndex] = options.remote;
-        else remotes.push(options.remote);
+    const configuredRemote = options.remote;
+    if (void 0 !== configuredRemote) {
+        const existingIndex = remotes.findIndex((remote)=>remote.name === configuredRemote.name);
+        if (existingIndex >= 0) remotes[existingIndex] = configuredRemote;
+        else remotes.push(configuredRemote);
     }
     return remotes;
 }

package/dist/esm/runtime/effect/backend-federation/runtime.mjs

@@ -1,26 +1,90 @@
+import { ModuleFederation } from "@module-federation/runtime";
 import { loadBackendFederationExpose } from "./entry.mjs";
+import { createBackendFederationLoadEntryPlugin } from "./plugin.mjs";
 import { collectRemotes } from "./remotes.mjs";
-import { normalizeExpose } from "./utils.mjs";
-function exposeForRemoteRequest(expose) {
-    return `./${normalizeExpose(expose)}`;
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
 }
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+let nextRuntimeId = 0;
 function parseRemoteRequest(request) {
     const [remoteName, ...exposeParts] = request.split('/');
-    if (!remoteName || 0 === exposeParts.length) throw new Error(`[BFF][Effect] Invalid backend federation request ${request}.`);
-    return {
-        remoteName,
-        expose: exposeForRemoteRequest(exposeParts.join('/'))
-    };
+    if (void 0 === remoteName || 0 === remoteName.length || 0 === exposeParts.length) return;
+    return remoteName;
+}
+function createLocalEntryPlugin(options, remotes) {
+    return createBackendFederationLoadEntryPlugin({
+        resolveEntry (resolvedRemote) {
+            const remote = remotes.find((candidate)=>candidate.name === resolvedRemote.name);
+            if (void 0 === remote) return;
+            return {
+                get (expose) {
+                    return ()=>loadBackendFederationExpose(remote, expose, options);
+                }
+            };
+        }
+    });
+}
+function isolateRegisteredRemoteEntries(remotes) {
+    const runtimeId = nextRuntimeId;
+    nextRuntimeId += 1;
+    return remotes.map((remote)=>({
+            ...remote,
+            entry: `${remote.entry}#modernjs-backend-runtime-${runtimeId}`
+        }));
+}
+var _remoteNames = /*#__PURE__*/ new WeakMap();
+class BackendFederationRuntime extends ModuleFederation {
+    loadRemote(request, loadOptions) {
+        const remoteName = parseRemoteRequest(request);
+        if (void 0 === remoteName) return Promise.reject(new Error(`[BFF][Effect] Invalid backend federation request ${request}.`));
+        if (!_class_private_field_get(this, _remoteNames).has(remoteName)) return Promise.reject(new Error(`[BFF][Effect] Missing backend federation remote ${remoteName}.`));
+        return super.loadRemote(request, loadOptions);
+    }
+    constructor(options, remotes){
+        super({
+            name: options.hostName,
+            remotes: isolateRegisteredRemoteEntries(remotes),
+            shared: {},
+            plugins: [
+                createLocalEntryPlugin(options, remotes)
+            ]
+        }), _class_private_field_init(this, _remoteNames, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _remoteNames, new Set(remotes.map((remote)=>remote.name)));
+    }
 }
 function createBackendFederationRuntime(options) {
     const remotes = collectRemotes(options);
-    return {
-        async loadRemote (request) {
-            const { remoteName, expose } = parseRemoteRequest(request);
-            const remote = remotes.find((candidate)=>candidate.name === remoteName);
-            if (!remote) throw new Error(`[BFF][Effect] Missing backend federation remote ${remoteName}.`);
-            return loadBackendFederationExpose(remote, expose, options);
-        }
-    };
+    return new BackendFederationRuntime(options, remotes);
 }
 export { createBackendFederationRuntime };

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

@@ -0,0 +1,38 @@
+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 };

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

@@ -1,39 +1,2 @@
-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 * 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 { createEffectOperationContext } from "./operation-context.mjs";
-export { createEffectBffEdgeDispatcher, createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest, runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm/runtime/effect/endpoint-contracts.mjs

@@ -1,5 +1,10 @@
 import { createOperationContractHash } from "@modern-js/bff-core";
 import { classifyEffectBffEntryModule, isValidatorAwareHandlerFactory } from "./entry-shape.mjs";
+function resolveEffectEndpointName(endpoint) {
+    if ('string' == typeof endpoint.identifier && endpoint.identifier) return endpoint.identifier;
+    if ('string' == typeof endpoint.name && endpoint.name) return endpoint.name;
+    return '';
+}
 function ensureLeadingSlash(pathname) {
     return pathname.startsWith('/') ? pathname : `/${pathname}`;
 }
@@ -28,7 +33,7 @@ function collectEffectEndpoints(reflect, api, prefix) {
             endpoints.push({
                 apiId,
                 groupName: String(group.identifier),
-                endpointName: String(endpoint.name),
+                endpointName: resolveEffectEndpointName(endpoint),
                 method: String(endpoint.method).toUpperCase(),
                 routePath: getEffectRoutePath(prefix, String(endpoint.path))
             });

package/dist/esm/runtime/effect/handler/definition.mjs

@@ -16,6 +16,7 @@ function defineEffectBff(definition) {
             openapi: options?.openapi,
             rpc: mergedRpcOptions,
             dataPlatform: mergeDataPlatformOptions(definition.dataPlatform, options?.dataPlatform),
+            interceptRequest: definition.interceptRequest,
             validateRequest: options?.validateRequest
         });
     };

package/dist/esm/runtime/effect/handler/http.mjs

@@ -12,23 +12,30 @@ function createHttpApiHandler(options) {
     const openApiLayer = createOpenApiLayer(options.api, options.openapi);
     const mergedLayer = openApiLayer ? __rspack_external_effect_Layer_69c46453.mergeAll(apiLayer, openApiLayer) : apiLayer;
     const httpApiHandler = HttpRouter.toWebHandler(mergedLayer);
-    const withDataPlatformValidation = async (request, context)=>{
-        const policyDenial = options.validateRequest?.(request);
-        if (policyDenial) return policyDenial;
+    const dispatchHttpApiRequest = async (request, context)=>{
         const preparedRequest = await prepareJsonRequestBody(request);
         if (preparedRequest instanceof Response) return preparedRequest;
         const validationError = validateDataPlatformRequestEnvelope(preparedRequest, options.dataPlatform);
         if (validationError) return validationError;
         return httpApiHandler.handler(preparedRequest, toEffectServiceContext(context));
     };
+    const withRequestPolicy = async (request, context)=>{
+        const policyDenial = options.validateRequest?.(request);
+        if (policyDenial) return policyDenial;
+        const next = ()=>dispatchHttpApiRequest(request, context);
+        return options.interceptRequest ? options.interceptRequest({
+            request,
+            next
+        }) : next();
+    };
     const batchHandler = createDataPlatformBatchRequestHandler({
         dataPlatform: options.dataPlatform,
-        handleItem: withDataPlatformValidation
+        handleItem: withRequestPolicy
     });
     const handleHttpApiRequest = async (request, context)=>{
         const pathname = getRequestPathname(request);
         if (batchHandler.enabled && pathname === batchHandler.path) return batchHandler.handle(request, context);
-        return withDataPlatformValidation(request, context);
+        return withRequestPolicy(request, context);
     };
     if (!options.rpc) return {
         handler: handleHttpApiRequest,
@@ -43,7 +50,11 @@ function createHttpApiHandler(options) {
             if (isRpcRequest(request, rpcPath)) {
                 const policyDenial = options.validateRequest?.(request);
                 if (policyDenial) return policyDenial;
-                return rpcHandler.handler(request, toEffectServiceContext(context));
+                const next = ()=>rpcHandler.handler(request, toEffectServiceContext(context));
+                return options.interceptRequest ? options.interceptRequest({
+                    request,
+                    next
+                }) : next();
             }
             return handleHttpApiRequest(request, context);
         },

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

@@ -1,5 +1,4 @@
-import { Hono, run } from "@modern-js/server-core";
-import { isProd, logger } from "@modern-js/utils";
+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";
@@ -8,17 +7,9 @@ const before = [
     'custom-server-middleware',
     'render'
 ];
-const kParentHonoVars = Symbol.for('modernjs.hono.parentVars');
 class HonoAdapter {
-    wrapInArray(handler) {
-        if (Array.isArray(handler)) return handler;
-        return [
-            handler
-        ];
-    }
     constructor(api){
         this.apiMiddleware = [];
-        this.apiServer = null;
         this.isHono = true;
         this.prefix = '/api';
         this.setHandlers = async ()=>{
@@ -29,7 +20,7 @@ class HonoAdapter {
                     name: 'hono-bff-api',
                     path,
                     method,
-                    handler,
+                    handler: this.withErrorBoundary(handler),
                     order: 'post',
                     before: before
                 }));
@@ -50,85 +41,47 @@ class HonoAdapter {
                 });
             }
         };
-        this.registerApiRoutes = async ()=>{
-            if (!this.isHono) return;
-            this.apiServer = new Hono();
-            this.apiServer.use('*', run);
-            this.apiServer.use('*', async (c, next)=>{
-                const nodeReq = c.env?.node?.req;
-                const parentVars = nodeReq?.[kParentHonoVars];
-                if (parentVars && 'object' == typeof parentVars) {
-                    delete nodeReq[kParentHonoVars];
-                    for (const [key, value] of Object.entries(parentVars))if (void 0 === c.get(key)) c.set(key, value);
-                }
-                await next();
-            });
-            this.apiMiddleware.forEach(({ path = '*', method = 'all', handler })=>{
-                const handlers = this.wrapInArray(handler);
-                if (0 === handlers.length) return;
-                const firstHandler = handlers[0];
-                const restHandlers = handlers.slice(1);
-                const m = method;
-                const server = this.apiServer;
-                if (!server) return;
-                const register = server[m];
-                register.call(server, path, firstHandler, ...restHandlers);
-            });
-            this.apiServer.onError(async (err, c)=>{
-                try {
-                    const serverConfig = this.api.getServerConfig();
-                    const onErrorHandler = serverConfig?.onError;
-                    if (onErrorHandler) {
-                        const result = await onErrorHandler(err, c);
-                        if (result instanceof Response) return result;
-                    } else logger.error(err);
-                } catch (configError) {
-                    logger.error(`Error in serverConfig.onError handler: ${configError}`);
-                }
-                return createSafeFailureResponse(err);
-            });
-        };
-        this.registerMiddleware = async (options)=>{
-            const { prefix } = 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();
-            if (isProd()) globalMiddlewares.push(...this.apiMiddleware);
-            else {
-                await this.registerApiRoutes();
-                const dynamicApiMiddleware = {
-                    name: 'dynamic-bff-handler',
-                    path: `${prefix}/*`,
-                    method: 'all',
-                    order: 'post',
-                    before: before,
-                    handler: async (c, next)=>{
-                        if (this.apiServer) {
-                            const nodeReq = c.env?.node?.req;
-                            if (nodeReq) {
-                                const parentVars = c?.var;
-                                nodeReq[kParentHonoVars] = parentVars && 'object' == typeof parentVars ? {
-                                    ...parentVars
-                                } : parentVars;
-                            }
-                            const response = await this.apiServer.fetch(c.req.raw, c.env);
-                            if (404 !== response.status) return new Response(response.body, response);
-                        }
-                        await next();
-                    }
-                };
-                globalMiddlewares.push(dynamicApiMiddleware);
+            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.onApiHandlersUpdated = async ()=>{
-            if (!this.isHono) return;
-            await this.setHandlers();
-            await this.registerApiRoutes();
+        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;
     }