@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.101 → 3.5.0-ultramodern.103

package/dist/cjs/runtime/effect/backend-federation/load.js

@@ -31,31 +31,40 @@ __webpack_require__.d(__webpack_exports__, {
     loadBackendFederatedEffectApi: ()=>loadBackendFederatedEffectApi
 });
 const universal_namespaceObject = require("@modern-js/utils/universal");
+const Effect_namespaceObject = require("effect/Effect");
+const Logger_namespaceObject = require("effect/Logger");
 const external_identity_js_namespaceObject = require("./identity.js");
 const external_runtime_js_namespaceObject = require("./runtime.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 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 = Logger_namespaceObject.withLeveledConsole(Logger_namespaceObject.formatLogFmt);
+function warnLegacyLoad() {
+    Effect_namespaceObject.runSync(Effect_namespaceObject.provideService(Effect_namespaceObject.logWarning(LEGACY_LOAD_WARNING), Logger_namespaceObject.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 ?? (0, external_runtime_js_namespaceObject.createBackendFederationRuntime)(options);
     const expose = options.expose ?? options.remote?.expose ?? universal_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE;
     const remoteRequest = `${remoteName}/${(0, external_utils_js_namespaceObject.normalizeExpose)(expose)}`;
-    const loaded = await runtime.loadRemote(remoteRequest);
-    if (!(0, external_utils_js_namespaceObject.isRecord)(loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must load an object module.`);
-    const backendContract = loaded.backendFederationContract;
-    if (!(0, external_utils_js_namespaceObject.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 = (0, external_identity_js_namespaceObject.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: ${(0, external_identity_js_namespaceObject.formatBackendFederationIdentityIssues)(issues)}.`);
-    }
-    return loaded;
+    return runtime.loadRemote(remoteRequest).then((loaded)=>{
+        if (!(0, external_utils_js_namespaceObject.isRecord)(loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must load an object module.`);
+        const backendContract = loaded.backendFederationContract;
+        if (!(0, external_utils_js_namespaceObject.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 = (0, external_identity_js_namespaceObject.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: ${(0, external_identity_js_namespaceObject.formatBackendFederationIdentityIssues)(issues)}.`);
+        }
+        return loaded;
+    });
 }
 exports.loadBackendFederatedEffectApi = __webpack_exports__.loadBackendFederatedEffectApi;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/runtime/effect/backend-federation/plugin.js

@@ -30,13 +30,23 @@ __webpack_require__.r(__webpack_exports__);
 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/cjs/runtime/effect/backend-federation/remotes.js

@@ -31,10 +31,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/cjs/runtime/effect/backend-federation/runtime.js

@@ -30,30 +30,94 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createBackendFederationRuntime: ()=>createBackendFederationRuntime
 });
+const runtime_namespaceObject = require("@module-federation/runtime");
 const external_entry_js_namespaceObject = require("./entry.js");
+const external_plugin_js_namespaceObject = require("./plugin.js");
 const external_remotes_js_namespaceObject = require("./remotes.js");
-const external_utils_js_namespaceObject = require("./utils.js");
-function exposeForRemoteRequest(expose) {
-    return `./${(0, external_utils_js_namespaceObject.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 (0, external_plugin_js_namespaceObject.createBackendFederationLoadEntryPlugin)({
+        resolveEntry (resolvedRemote) {
+            const remote = remotes.find((candidate)=>candidate.name === resolvedRemote.name);
+            if (void 0 === remote) return;
+            return {
+                get (expose) {
+                    return ()=>(0, external_entry_js_namespaceObject.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 runtime_namespaceObject.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 = (0, external_remotes_js_namespaceObject.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 (0, external_entry_js_namespaceObject.loadBackendFederationExpose)(remote, expose, options);
-        }
-    };
+    return new BackendFederationRuntime(options, remotes);
 }
 exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/runtime/effect/edge-dispatcher.js

@@ -0,0 +1,148 @@
+"use strict";
+var __webpack_modules__ = {
+    "./dispatch" (module) {
+        module.exports = require("./dispatch.js");
+    },
+    "./edge-context" (module) {
+        module.exports = require("./edge-context.js");
+    },
+    "./handler" (module) {
+        module.exports = require("./handler.js");
+    },
+    "./module" (module) {
+        module.exports = require("./module.js");
+    },
+    "./operation-context" (module) {
+        module.exports = require("./operation-context.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _dispatch__rspack_import_0 = __webpack_require__("./dispatch");
+    var _edge_context__rspack_import_1 = __webpack_require__("./edge-context");
+    var _module__rspack_import_2 = __webpack_require__("./module");
+    var _handler__rspack_import_3 = __webpack_require__("./handler");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _handler__rspack_import_3)if ([
+        "runWithEffectContext",
+        "useEffectContext",
+        "default",
+        "useOperationContext",
+        "createEffectOperationContext",
+        "dispatchEffectBffRequest",
+        "createEffectBffTestHandler",
+        "createEffectBffEdgeHandler",
+        "createEffectBffEdgeDispatcher"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _operation_context__rspack_import_4 = __webpack_require__("./operation-context");
+    async function dispatchEffectBffRequest(handler, request, options = {}) {
+        return (0, _dispatch__rspack_import_0.dispatchEffectBffRequestWithContext)(handler, request, {
+            ...options,
+            runWithEffectContext: _edge_context__rspack_import_1.runWithEffectContext
+        });
+    }
+    async function createEffectBffEdgeDispatcher(options) {
+        const loaded = await (0, _module__rspack_import_2.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
+        };
+    }
+    __webpack_require__.d(__webpack_exports__, {
+        createEffectBffEdgeDispatcher: ()=>createEffectBffEdgeDispatcher,
+        createEffectBffEdgeHandler: ()=>createEffectBffEdgeHandler,
+        createEffectOperationContext: ()=>_operation_context__rspack_import_4.createEffectOperationContext,
+        dispatchEffectBffRequest: ()=>dispatchEffectBffRequest,
+        runWithEffectContext: ()=>_edge_context__rspack_import_1.runWithEffectContext,
+        useEffectContext: ()=>_edge_context__rspack_import_1.useEffectContext,
+        useOperationContext: ()=>_edge_context__rspack_import_1.useOperationContext
+    }, {
+        createEffectBffTestHandler: createEffectBffTestHandler
+    });
+})();
+exports.createEffectBffEdgeDispatcher = __webpack_exports__.createEffectBffEdgeDispatcher;
+exports.createEffectBffEdgeHandler = __webpack_exports__.createEffectBffEdgeHandler;
+exports.createEffectBffTestHandler = __webpack_exports__.createEffectBffTestHandler;
+exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
+exports.dispatchEffectBffRequest = __webpack_exports__.dispatchEffectBffRequest;
+exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
+exports.useEffectContext = __webpack_exports__.useEffectContext;
+exports.useOperationContext = __webpack_exports__.useOperationContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEffectBffEdgeDispatcher",
+    "createEffectBffEdgeHandler",
+    "createEffectBffTestHandler",
+    "createEffectOperationContext",
+    "dispatchEffectBffRequest",
+    "runWithEffectContext",
+    "useEffectContext",
+    "useOperationContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/edge.js

@@ -3,20 +3,8 @@ var __webpack_modules__ = {
     "./backend-federation" (module) {
         module.exports = require("./backend-federation.js");
     },
-    "./dispatch" (module) {
-        module.exports = require("./dispatch.js");
-    },
-    "./edge-context" (module) {
-        module.exports = require("./edge-context.js");
-    },
-    "./handler" (module) {
-        module.exports = require("./handler.js");
-    },
-    "./module" (module) {
-        module.exports = require("./module.js");
-    },
-    "./operation-context" (module) {
-        module.exports = require("./operation-context.js");
+    "./edge-dispatcher" (module) {
+        module.exports = require("./edge-dispatcher.js");
     }
 };
 var __webpack_module_cache__ = {};
@@ -66,83 +54,30 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var _dispatch__rspack_import_0 = __webpack_require__("./dispatch");
-    var _edge_context__rspack_import_1 = __webpack_require__("./edge-context");
-    var _module__rspack_import_2 = __webpack_require__("./module");
-    var _backend_federation__rspack_import_3 = __webpack_require__("./backend-federation");
-    var _handler__rspack_import_4 = __webpack_require__("./handler");
+    var _backend_federation__rspack_import_0 = __webpack_require__("./backend-federation");
+    var _edge_dispatcher__rspack_import_1 = __webpack_require__("./edge-dispatcher");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _handler__rspack_import_4)if ([
+    for(const __rspack_import_key in _edge_dispatcher__rspack_import_1)if ([
         "validateExpectedBackendFederationIdentity",
-        "createBackendFederationLoadEntryPlugin",
-        "useOperationContext",
-        "BACKEND_FEDERATION_MANIFEST_FILE",
-        "createEffectOperationContext",
-        "loadBackendFederatedEffectApi",
-        "BACKEND_FEDERATION_CONTRACT_VERSION",
-        "createEffectBffEdgeHandler",
-        "runWithEffectContext",
         "BACKEND_FEDERATION_EFFECT_EXPOSE",
-        "useEffectContext",
-        "dispatchEffectBffRequest",
         "default",
+        "createBackendFederationLoadEntryPlugin",
+        "BACKEND_FEDERATION_MANIFEST_FILE",
         "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
-        "createEffectBffTestHandler",
-        "createBackendFederationRuntime",
-        "createEffectBffEdgeDispatcher"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_4[__rspack_import_key];
+        "BACKEND_FEDERATION_CONTRACT_VERSION",
+        "loadBackendFederatedEffectApi",
+        "createBackendFederationRuntime"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_edge_dispatcher__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _operation_context__rspack_import_5 = __webpack_require__("./operation-context");
-    async function dispatchEffectBffRequest(handler, request, options = {}) {
-        return (0, _dispatch__rspack_import_0.dispatchEffectBffRequestWithContext)(handler, request, {
-            ...options,
-            runWithEffectContext: _edge_context__rspack_import_1.runWithEffectContext
-        });
-    }
-    async function createEffectBffEdgeDispatcher(options) {
-        const loaded = await (0, _module__rspack_import_2.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
-        };
-    }
     __webpack_require__.d(__webpack_exports__, {
-        BACKEND_FEDERATION_CONTRACT_VERSION: ()=>_backend_federation__rspack_import_3.BACKEND_FEDERATION_CONTRACT_VERSION,
-        BACKEND_FEDERATION_EFFECT_EXPOSE: ()=>_backend_federation__rspack_import_3.BACKEND_FEDERATION_EFFECT_EXPOSE,
-        BACKEND_FEDERATION_MANIFEST_FILE: ()=>_backend_federation__rspack_import_3.BACKEND_FEDERATION_MANIFEST_FILE,
-        BACKEND_FEDERATION_NODE_ADAPTER_VERSION: ()=>_backend_federation__rspack_import_3.BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
-        createBackendFederationLoadEntryPlugin: ()=>_backend_federation__rspack_import_3.createBackendFederationLoadEntryPlugin,
-        createBackendFederationRuntime: ()=>_backend_federation__rspack_import_3.createBackendFederationRuntime,
-        createEffectBffEdgeDispatcher: ()=>createEffectBffEdgeDispatcher,
-        createEffectBffEdgeHandler: ()=>createEffectBffEdgeHandler,
-        createEffectOperationContext: ()=>_operation_context__rspack_import_5.createEffectOperationContext,
-        dispatchEffectBffRequest: ()=>dispatchEffectBffRequest,
-        loadBackendFederatedEffectApi: ()=>_backend_federation__rspack_import_3.loadBackendFederatedEffectApi,
-        runWithEffectContext: ()=>_edge_context__rspack_import_1.runWithEffectContext,
-        useEffectContext: ()=>_edge_context__rspack_import_1.useEffectContext,
-        useOperationContext: ()=>_edge_context__rspack_import_1.useOperationContext,
-        validateExpectedBackendFederationIdentity: ()=>_backend_federation__rspack_import_3.validateExpectedBackendFederationIdentity
-    }, {
-        createEffectBffTestHandler: createEffectBffTestHandler
+        BACKEND_FEDERATION_CONTRACT_VERSION: ()=>_backend_federation__rspack_import_0.BACKEND_FEDERATION_CONTRACT_VERSION,
+        BACKEND_FEDERATION_EFFECT_EXPOSE: ()=>_backend_federation__rspack_import_0.BACKEND_FEDERATION_EFFECT_EXPOSE,
+        BACKEND_FEDERATION_MANIFEST_FILE: ()=>_backend_federation__rspack_import_0.BACKEND_FEDERATION_MANIFEST_FILE,
+        BACKEND_FEDERATION_NODE_ADAPTER_VERSION: ()=>_backend_federation__rspack_import_0.BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+        createBackendFederationLoadEntryPlugin: ()=>_backend_federation__rspack_import_0.createBackendFederationLoadEntryPlugin,
+        createBackendFederationRuntime: ()=>_backend_federation__rspack_import_0.createBackendFederationRuntime,
+        loadBackendFederatedEffectApi: ()=>_backend_federation__rspack_import_0.loadBackendFederatedEffectApi,
+        validateExpectedBackendFederationIdentity: ()=>_backend_federation__rspack_import_0.validateExpectedBackendFederationIdentity
     });
 })();
 exports.BACKEND_FEDERATION_CONTRACT_VERSION = __webpack_exports__.BACKEND_FEDERATION_CONTRACT_VERSION;
@@ -151,15 +86,7 @@ exports.BACKEND_FEDERATION_MANIFEST_FILE = __webpack_exports__.BACKEND_FEDERATIO
 exports.BACKEND_FEDERATION_NODE_ADAPTER_VERSION = __webpack_exports__.BACKEND_FEDERATION_NODE_ADAPTER_VERSION;
 exports.createBackendFederationLoadEntryPlugin = __webpack_exports__.createBackendFederationLoadEntryPlugin;
 exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
-exports.createEffectBffEdgeDispatcher = __webpack_exports__.createEffectBffEdgeDispatcher;
-exports.createEffectBffEdgeHandler = __webpack_exports__.createEffectBffEdgeHandler;
-exports.createEffectBffTestHandler = __webpack_exports__.createEffectBffTestHandler;
-exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
-exports.dispatchEffectBffRequest = __webpack_exports__.dispatchEffectBffRequest;
 exports.loadBackendFederatedEffectApi = __webpack_exports__.loadBackendFederatedEffectApi;
-exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
-exports.useEffectContext = __webpack_exports__.useEffectContext;
-exports.useOperationContext = __webpack_exports__.useOperationContext;
 exports.validateExpectedBackendFederationIdentity = __webpack_exports__.validateExpectedBackendFederationIdentity;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "BACKEND_FEDERATION_CONTRACT_VERSION",
@@ -168,15 +95,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
     "createBackendFederationLoadEntryPlugin",
     "createBackendFederationRuntime",
-    "createEffectBffEdgeDispatcher",
-    "createEffectBffEdgeHandler",
-    "createEffectBffTestHandler",
-    "createEffectOperationContext",
-    "dispatchEffectBffRequest",
     "loadBackendFederatedEffectApi",
-    "runWithEffectContext",
-    "useEffectContext",
-    "useOperationContext",
     "validateExpectedBackendFederationIdentity"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/runtime/effect/handler/definition.js

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

package/dist/cjs/runtime/effect/handler/http.js

@@ -44,23 +44,30 @@ function createHttpApiHandler(options) {
     const openApiLayer = (0, external_openapi_js_namespaceObject.createOpenApiLayer)(options.api, options.openapi);
     const mergedLayer = openApiLayer ? Layer_namespaceObject.mergeAll(apiLayer, openApiLayer) : apiLayer;
     const httpApiHandler = http_namespaceObject.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 (0, external_batch_js_namespaceObject.prepareJsonRequestBody)(request);
         if (preparedRequest instanceof Response) return preparedRequest;
         const validationError = (0, external_envelope_js_namespaceObject.validateDataPlatformRequestEnvelope)(preparedRequest, options.dataPlatform);
         if (validationError) return validationError;
         return httpApiHandler.handler(preparedRequest, (0, external_types_js_namespaceObject.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 = (0, external_batch_handler_js_namespaceObject.createDataPlatformBatchRequestHandler)({
         dataPlatform: options.dataPlatform,
-        handleItem: withDataPlatformValidation
+        handleItem: withRequestPolicy
     });
     const handleHttpApiRequest = async (request, context)=>{
         const pathname = (0, external_routing_js_namespaceObject.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,
@@ -75,7 +82,11 @@ function createHttpApiHandler(options) {
             if ((0, external_routing_js_namespaceObject.isRpcRequest)(request, rpcPath)) {
                 const policyDenial = options.validateRequest?.(request);
                 if (policyDenial) return policyDenial;
-                return rpcHandler.handler(request, (0, external_types_js_namespaceObject.toEffectServiceContext)(context));
+                const next = ()=>rpcHandler.handler(request, (0, external_types_js_namespaceObject.toEffectServiceContext)(context));
+                return options.interceptRequest ? options.interceptRequest({
+                    request,
+                    next
+                }) : next();
             }
             return handleHttpApiRequest(request, context);
         },