@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.10 → 3.5.0-ultramodern.100

package/dist/cjs/runtime/effect/backend-federation-manifest/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/backend-federation-manifest/validation.js

@@ -0,0 +1,109 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+__webpack_require__.d(__webpack_exports__, {
+    classifyLoadError: ()=>classifyLoadError,
+    validateBackendFederationManifest: ()=>validateBackendFederationManifest,
+    validateLoadedBackendFederationContract: ()=>validateLoadedBackendFederationContract
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const external_backend_federation_js_namespaceObject = require("../backend-federation.js");
+const external_errors_js_namespaceObject = require("./errors.js");
+const external_metadata_js_namespaceObject = require("./metadata.js");
+function resolveExpectedBuildMarker(expected) {
+    if (void 0 !== expected.buildVersion && void 0 !== expected.buildMarker && expected.buildVersion !== expected.buildMarker) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation expected buildVersion/buildMarker mismatch: buildVersion ${expected.buildVersion}, buildMarker ${expected.buildMarker}.`, void 0, {
+        label: 'expected.buildVersion/buildMarker',
+        expected: expected.buildVersion,
+        received: expected.buildMarker
+    });
+    return expected.buildMarker;
+}
+function validateBackendFederationManifest(manifest, expected = {}) {
+    const expectedBuildMarker = resolveExpectedBuildMarker(expected);
+    const backendFederation = (0, external_metadata_js_namespaceObject.backendFederationMetadata)(manifest);
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(backendFederation, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare backendFederation metadata.');
+    const manifestShape = (0, universal_namespaceObject.validateBackendFederationManifest)(manifest, {
+        expectedContractVersion: false,
+        expectedNodeAdapterVersion: false,
+        validateDeliveryUnit: false
+    });
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(manifestShape.ok, 'manifest_invalid', `[BFF][Effect] Backend federation manifest schema invalid: ${(0, universal_namespaceObject.formatBackendFederationValidationErrors)(manifestShape.errors)}.`);
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)('effect' === backendFederation.runtimeFramework, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare runtimeFramework: "effect".');
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(true === backendFederation.strictEffectApproach, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare strictEffectApproach: true.');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(backendFederation.contractVersion), expected.contractVersion ?? external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_CONTRACT_VERSION, 'manifest contractVersion');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(backendFederation.nodeAdapterVersion), expected.nodeAdapterVersion ?? external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_NODE_ADAPTER_VERSION, 'manifest nodeAdapterVersion');
+    const boundary = (0, external_metadata_js_namespaceObject.versionBoundaryMetadata)(manifest);
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(backendFederation.name) ?? (0, external_metadata_js_namespaceObject.stringValue)(manifest.name) ?? (0, external_metadata_js_namespaceObject.stringValue)(manifest.id), expected.remoteName, 'manifest remoteName');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(boundary?.packageName), expected.packageName, 'versionBoundary.packageName');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(boundary?.version), expected.version, 'versionBoundary.version');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), expected.buildVersion, 'versionBoundary.buildVersion');
+    (0, external_errors_js_namespaceObject.assertConsistentValue)((0, external_metadata_js_namespaceObject.stringValue)(manifest.version), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.version), 'manifest versionBoundary.version');
+    (0, external_errors_js_namespaceObject.assertConsistentValue)((0, external_metadata_js_namespaceObject.stringValue)(manifest.buildVersion), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'manifest versionBoundary.buildVersion');
+    const deliveryUnit = (0, external_metadata_js_namespaceObject.manifestDeliveryUnit)(backendFederation, boundary);
+    (0, external_errors_js_namespaceObject.assertConsistentValue)((0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'versionBoundary.deliveryUnit.buildMarker vs versionBoundary.buildVersion');
+    (0, external_errors_js_namespaceObject.assertConsistentValue)((0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId), (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId), 'backendFederation.deliveryUnit.unitId vs versionBoundary.deliveryUnit.unitId');
+    const manifestUnitId = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId) ?? (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId);
+    (0, external_errors_js_namespaceObject.assertVersionValue)(manifestUnitId, expected.unitId, 'deliveryUnit.unitId');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker), expectedBuildMarker, 'deliveryUnit.buildMarker');
+}
+function validateLoadedBackendFederationContract(loaded, manifest, remote) {
+    const loadedContract = loaded.backendFederationContract;
+    const backendFederation = (0, external_metadata_js_namespaceObject.backendFederationMetadata)(manifest);
+    const boundary = (0, external_metadata_js_namespaceObject.versionBoundaryMetadata)(manifest);
+    const compatibility = (0, external_metadata_js_namespaceObject.recordField)(loadedContract, 'compatibility');
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(compatibility, 'version_mismatch', `[BFF][Effect] Backend federation expose ${remote.name}/${remote.expose?.replace(/^\.\//u, '')} must declare compatibility metadata.`);
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(loadedContract?.role), 'microvertical-server', 'expose role');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(loadedContract?.name), remote.name, 'expose name');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.contractVersion), (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.contractVersion), 'expose contractVersion');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.nodeAdapterVersion), (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.nodeAdapterVersion), 'expose nodeAdapterVersion');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.packageName), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.packageName), 'expose packageName');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'expose buildVersion');
+    const deliveryUnit = (0, external_metadata_js_namespaceObject.manifestDeliveryUnit)(backendFederation, boundary);
+    const manifestUnitId = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId) ?? (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId);
+    const manifestBuildMarker = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker);
+    (0, external_errors_js_namespaceObject.assertConsistentValue)(manifestUnitId, (0, external_metadata_js_namespaceObject.stringValue)(compatibility.unitId), 'deliveryUnit.unitId vs expose compatibility.unitId');
+    (0, external_errors_js_namespaceObject.assertConsistentValue)(manifestBuildMarker, (0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), 'deliveryUnit.buildMarker vs expose compatibility.build');
+}
+function classifyLoadError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes('delivery-unit identity mismatch')) return 'version_mismatch';
+    if (message.includes('strictEffectApproach') || message.includes('runtimeFramework')) return 'strict_effect_required';
+    return 'remote_unavailable';
+}
+exports.classifyLoadError = __webpack_exports__.classifyLoadError;
+exports.validateBackendFederationManifest = __webpack_exports__.validateBackendFederationManifest;
+exports.validateLoadedBackendFederationContract = __webpack_exports__.validateLoadedBackendFederationContract;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "classifyLoadError",
+    "validateBackendFederationManifest",
+    "validateLoadedBackendFederationContract"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,62 @@
+"use strict";
+var __webpack_modules__ = {
+    "./backend-federation-manifest/index" (module) {
+        module.exports = require("./backend-federation-manifest/index.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 _backend_federation_manifest_index__rspack_import_0 = __webpack_require__("./backend-federation-manifest/index");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _backend_federation_manifest_index__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_backend_federation_manifest_index__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,65 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+__webpack_require__.d(__webpack_exports__, {
+    BACKEND_FEDERATION_CONTRACT_VERSION: ()=>universal_namespaceObject.BACKEND_FEDERATION_CONTRACT_VERSION,
+    BACKEND_FEDERATION_EFFECT_EXPOSE: ()=>universal_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE,
+    BACKEND_FEDERATION_MANIFEST_FILE: ()=>universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+    BACKEND_FEDERATION_NODE_ADAPTER_VERSION: ()=>universal_namespaceObject.BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+    createBackendFederationLoadEntryPlugin: ()=>plugin_js_namespaceObject.createBackendFederationLoadEntryPlugin,
+    createBackendFederationRuntime: ()=>runtime_js_namespaceObject.createBackendFederationRuntime,
+    loadBackendFederatedEffectApi: ()=>load_js_namespaceObject.loadBackendFederatedEffectApi,
+    validateExpectedBackendFederationIdentity: ()=>identity_js_namespaceObject.validateExpectedBackendFederationIdentity
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const identity_js_namespaceObject = require("./backend-federation/identity.js");
+const load_js_namespaceObject = require("./backend-federation/load.js");
+const plugin_js_namespaceObject = require("./backend-federation/plugin.js");
+const runtime_js_namespaceObject = require("./backend-federation/runtime.js");
+exports.BACKEND_FEDERATION_CONTRACT_VERSION = __webpack_exports__.BACKEND_FEDERATION_CONTRACT_VERSION;
+exports.BACKEND_FEDERATION_EFFECT_EXPOSE = __webpack_exports__.BACKEND_FEDERATION_EFFECT_EXPOSE;
+exports.BACKEND_FEDERATION_MANIFEST_FILE = __webpack_exports__.BACKEND_FEDERATION_MANIFEST_FILE;
+exports.BACKEND_FEDERATION_NODE_ADAPTER_VERSION = __webpack_exports__.BACKEND_FEDERATION_NODE_ADAPTER_VERSION;
+exports.createBackendFederationLoadEntryPlugin = __webpack_exports__.createBackendFederationLoadEntryPlugin;
+exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
+exports.loadBackendFederatedEffectApi = __webpack_exports__.loadBackendFederatedEffectApi;
+exports.validateExpectedBackendFederationIdentity = __webpack_exports__.validateExpectedBackendFederationIdentity;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BACKEND_FEDERATION_CONTRACT_VERSION",
+    "BACKEND_FEDERATION_EFFECT_EXPOSE",
+    "BACKEND_FEDERATION_MANIFEST_FILE",
+    "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
+    "createBackendFederationLoadEntryPlugin",
+    "createBackendFederationRuntime",
+    "loadBackendFederatedEffectApi",
+    "validateExpectedBackendFederationIdentity"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,101 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+__webpack_require__.d(__webpack_exports__, {
+    dispatchEffectBffRequestWithContext: ()=>dispatchEffectBffRequestWithContext
+});
+const external_safe_failure_js_namespaceObject = require("../safe-failure.js");
+const external_operation_context_js_namespaceObject = require("./operation-context.js");
+function normalizeEffectBffPrefix(prefix) {
+    if (!prefix || '/' === prefix) return '';
+    return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+}
+function removeEffectBffPrefixFromPath(pathname, prefix) {
+    const normalized = normalizeEffectBffPrefix(prefix);
+    if (!normalized || pathname !== normalized && !pathname.startsWith(`${normalized}/`)) return pathname;
+    const sliced = pathname.slice(normalized.length);
+    return sliced.startsWith('/') ? sliced : `/${sliced}`;
+}
+function matchesEffectBffPrefix(pathname, prefix) {
+    const normalized = normalizeEffectBffPrefix(prefix);
+    return !normalized || pathname === normalized || pathname.startsWith(`${normalized}/`);
+}
+function createEffectBffMountedRequest(req, prefix) {
+    const url = new URL(req.url);
+    const nextPath = removeEffectBffPrefixFromPath(url.pathname, prefix);
+    if (nextPath !== url.pathname) {
+        url.pathname = nextPath;
+        return new Request(url, req);
+    }
+    return req;
+}
+function createEffectBffDispatchContext(originalRequest, mountedRequest, options) {
+    const path = options.path ?? new URL(originalRequest.url).pathname;
+    const method = options.method ?? originalRequest.method;
+    const env = options.env ?? {};
+    return {
+        request: mountedRequest,
+        env,
+        path,
+        method,
+        operationContext: (0, external_operation_context_js_namespaceObject.createEffectOperationContext)({
+            request: mountedRequest,
+            env,
+            path,
+            method
+        })
+    };
+}
+async function dispatchEffectBffRequestWithContext(handler, request, options) {
+    const requestPath = new URL(request.url).pathname;
+    if (!matchesEffectBffPrefix(requestPath, options.prefix)) return new Response('', {
+        status: 404
+    });
+    const mountedRequest = createEffectBffMountedRequest(request, options.prefix);
+    const effectContext = createEffectBffDispatchContext(request, mountedRequest, options);
+    try {
+        const response = await options.runWithEffectContext(effectContext, ()=>handler(mountedRequest, effectContext));
+        if (!(response instanceof Response)) throw new Error('[BFF][Effect] Effect handler must return Response instance.');
+        return new Response(response.body, response);
+    } catch (error) {
+        if (error instanceof Response) return new Response(error.body, error);
+        if (options.onError) {
+            const errorResponse = await options.onError(error, effectContext);
+            if (errorResponse instanceof Response) return errorResponse;
+        }
+        return (0, external_safe_failure_js_namespaceObject.createSafeFailureResponse)(error);
+    }
+}
+exports.dispatchEffectBffRequestWithContext = __webpack_exports__.dispatchEffectBffRequestWithContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "dispatchEffectBffRequestWithContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -1,7 +1,10 @@
 "use strict";
 var __webpack_modules__ = {
-    "../safe-failure" (module) {
-        module.exports = require("../safe-failure.js");
+    "./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");
@@ -63,85 +66,40 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var _safe_failure__rspack_import_0 = __webpack_require__("../safe-failure");
+    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 _operation_context__rspack_import_3 = __webpack_require__("./operation-context");
+    var _backend_federation__rspack_import_3 = __webpack_require__("./backend-federation");
     var _handler__rspack_import_4 = __webpack_require__("./handler");
     var __rspack_reexport = {};
     for(const __rspack_import_key in _handler__rspack_import_4)if ([
-        "runWithEffectContext",
-        "useEffectContext",
-        "default",
+        "validateExpectedBackendFederationIdentity",
+        "createBackendFederationLoadEntryPlugin",
         "useOperationContext",
+        "BACKEND_FEDERATION_MANIFEST_FILE",
         "createEffectOperationContext",
+        "loadBackendFederatedEffectApi",
+        "BACKEND_FEDERATION_CONTRACT_VERSION",
+        "createEffectBffEdgeHandler",
+        "runWithEffectContext",
+        "BACKEND_FEDERATION_EFFECT_EXPOSE",
+        "useEffectContext",
         "dispatchEffectBffRequest",
+        "default",
+        "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
         "createEffectBffTestHandler",
-        "createEffectBffEdgeHandler"
+        "createBackendFederationRuntime",
+        "createEffectBffEdgeDispatcher"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_4[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    function normalizePrefix(prefix) {
-        if (!prefix || '/' === prefix) return '';
-        return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
-    }
-    function removePrefixFromPath(pathname, prefix) {
-        const normalized = normalizePrefix(prefix);
-        if (!normalized || pathname !== normalized && !pathname.startsWith(`${normalized}/`)) return pathname;
-        const sliced = pathname.slice(normalized.length);
-        return sliced.startsWith('/') ? sliced : `/${sliced}`;
-    }
-    function matchesPrefix(pathname, prefix) {
-        const normalized = normalizePrefix(prefix);
-        return !normalized || pathname === normalized || pathname.startsWith(`${normalized}/`);
-    }
-    function createRequestForMountedPrefix(req, prefix) {
-        const url = new URL(req.url);
-        const nextPath = removePrefixFromPath(url.pathname, prefix);
-        if (nextPath === url.pathname) return req;
-        url.pathname = nextPath;
-        return new Request(url, req);
-    }
-    function createEdgeEffectContext(originalRequest, effectRequest, options) {
-        const originalPath = options.path || new URL(originalRequest.url).pathname;
-        const method = options.method || originalRequest.method;
-        return {
-            request: effectRequest,
-            env: options.env || {},
-            path: originalPath,
-            method,
-            operationContext: (0, _operation_context__rspack_import_3.createEffectOperationContext)({
-                request: effectRequest,
-                env: options.env || {},
-                path: originalPath,
-                method
-            })
-        };
-    }
-    function createRuntimeErrorResponse(error) {
-        return (0, _safe_failure__rspack_import_0.createSafeFailureResponse)(error);
-    }
+    var _operation_context__rspack_import_5 = __webpack_require__("./operation-context");
     async function dispatchEffectBffRequest(handler, request, options = {}) {
-        const requestPathname = new URL(request.url).pathname;
-        if (!matchesPrefix(requestPathname, options.prefix)) return new Response(null, {
-            status: 404
+        return (0, _dispatch__rspack_import_0.dispatchEffectBffRequestWithContext)(handler, request, {
+            ...options,
+            runWithEffectContext: _edge_context__rspack_import_1.runWithEffectContext
         });
-        const effectRequest = createRequestForMountedPrefix(request, options.prefix);
-        const effectContext = createEdgeEffectContext(request, effectRequest, options);
-        try {
-            const response = await (0, _edge_context__rspack_import_1.runWithEffectContext)(effectContext, ()=>handler.length > 1 ? handler(effectRequest, effectContext) : handler(effectRequest));
-            if (!(response instanceof Response)) throw new Error('[BFF][Effect] Effect handler must return a Response instance.');
-            return new Response(response.body, response);
-        } catch (error) {
-            if (error instanceof Response) return new Response(error.body, error);
-            if (options.onError) {
-                const errorResponse = await options.onError(error, effectContext);
-                if (errorResponse instanceof Response) return errorResponse;
-            }
-            return createRuntimeErrorResponse(error);
-        }
     }
-    const createEffectBffTestHandler = createEffectBffEdgeHandler;
-    async function createEffectBffEdgeHandler(options) {
+    async function createEffectBffEdgeDispatcher(options) {
         const loaded = await (0, _module__rspack_import_2.resolveEffectBffModuleHandler)(options.module, {
             openapi: options.openapi,
             dataPlatform: options.dataPlatform,
@@ -149,7 +107,7 @@ var __webpack_exports__ = {};
         });
         if (!loaded) throw new Error('[BFF][Effect] Invalid Effect edge module. Export defineEffectBff(...) or a { api, layer } HttpApi module.');
         return {
-            handler: (request, dispatchOptions = {})=>dispatchEffectBffRequest(loaded.handler, request, {
+            dispatch: (request, dispatchOptions = {})=>dispatchEffectBffRequest(loaded.handler, request, {
                     ...dispatchOptions,
                     prefix: options.prefix,
                     onError: options.onError
@@ -159,32 +117,67 @@ var __webpack_exports__ = {};
             }
         };
     }
+    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_3.createEffectOperationContext,
+        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
+        useOperationContext: ()=>_edge_context__rspack_import_1.useOperationContext,
+        validateExpectedBackendFederationIdentity: ()=>_backend_federation__rspack_import_3.validateExpectedBackendFederationIdentity
     }, {
         createEffectBffTestHandler: createEffectBffTestHandler
     });
 })();
+exports.BACKEND_FEDERATION_CONTRACT_VERSION = __webpack_exports__.BACKEND_FEDERATION_CONTRACT_VERSION;
+exports.BACKEND_FEDERATION_EFFECT_EXPOSE = __webpack_exports__.BACKEND_FEDERATION_EFFECT_EXPOSE;
+exports.BACKEND_FEDERATION_MANIFEST_FILE = __webpack_exports__.BACKEND_FEDERATION_MANIFEST_FILE;
+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",
+    "BACKEND_FEDERATION_EFFECT_EXPOSE",
+    "BACKEND_FEDERATION_MANIFEST_FILE",
+    "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
+    "createBackendFederationLoadEntryPlugin",
+    "createBackendFederationRuntime",
+    "createEffectBffEdgeDispatcher",
     "createEffectBffEdgeHandler",
     "createEffectBffTestHandler",
     "createEffectOperationContext",
     "dispatchEffectBffRequest",
+    "loadBackendFederatedEffectApi",
     "runWithEffectContext",
     "useEffectContext",
-    "useOperationContext"
+    "useOperationContext",
+    "validateExpectedBackendFederationIdentity"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/runtime/effect/endpoint-contracts.js

@@ -30,15 +30,18 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     collectEffectEndpoints: ()=>collectEffectEndpoints,
     createEffectEndpointContractHash: ()=>createEffectEndpointContractHash,
-    createEffectOperationContractSource: ()=>createEffectOperationContractSource,
     ensureLeadingSlash: ()=>ensureLeadingSlash,
     extractHttpApiFromModule: ()=>extractHttpApiFromModule,
-    getEffectRoutePath: ()=>getEffectRoutePath,
     normalizeEffectPrefix: ()=>normalizeEffectPrefix,
-    resolveEffectApiId: ()=>resolveEffectApiId,
     toOperationContractSources: ()=>toOperationContractSources
 });
 const bff_core_namespaceObject = require("@modern-js/bff-core");
+const external_entry_shape_js_namespaceObject = require("./entry-shape.js");
+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}`;
 }
@@ -67,7 +70,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))
             });
@@ -88,41 +91,29 @@ function createEffectOperationContractSource(endpoint) {
         routePath: endpoint.routePath
     };
 }
-function isRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
 async function extractHttpApiFromModule(mod, isHttpApi) {
-    if (!isRecord(mod)) return null;
-    if (isHttpApi(mod.api)) return mod.api;
-    const entry = mod.default;
-    if (isRecord(entry) && isHttpApi(entry.api)) return entry.api;
-    if ('function' == typeof entry && 0 === entry.length) {
-        const output = await entry();
-        if (isRecord(output) && isHttpApi(output.api)) return output.api;
-    }
-    return null;
+    const facts = (0, external_entry_shape_js_namespaceObject.classifyEffectBffEntryModule)(mod, {
+        isRequestHandler: (value)=>'function' == typeof value,
+        isValidatorAwareHandlerFactory: external_entry_shape_js_namespaceObject.isValidatorAwareHandlerFactory,
+        isHttpApi
+    });
+    return !facts?.legacyShape && facts?.api !== void 0 && facts.hasRuntimeLayer && (void 0 === facts.createHandler || facts.createHandlerValidatorAware) ? facts.api : null;
 }
 function createEffectEndpointContractHash(endpoint, requestId) {
     return (0, bff_core_namespaceObject.createOperationContractHash)(createEffectOperationContractSource(endpoint), requestId);
 }
 exports.collectEffectEndpoints = __webpack_exports__.collectEffectEndpoints;
 exports.createEffectEndpointContractHash = __webpack_exports__.createEffectEndpointContractHash;
-exports.createEffectOperationContractSource = __webpack_exports__.createEffectOperationContractSource;
 exports.ensureLeadingSlash = __webpack_exports__.ensureLeadingSlash;
 exports.extractHttpApiFromModule = __webpack_exports__.extractHttpApiFromModule;
-exports.getEffectRoutePath = __webpack_exports__.getEffectRoutePath;
 exports.normalizeEffectPrefix = __webpack_exports__.normalizeEffectPrefix;
-exports.resolveEffectApiId = __webpack_exports__.resolveEffectApiId;
 exports.toOperationContractSources = __webpack_exports__.toOperationContractSources;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "collectEffectEndpoints",
     "createEffectEndpointContractHash",
-    "createEffectOperationContractSource",
     "ensureLeadingSlash",
     "extractHttpApiFromModule",
-    "getEffectRoutePath",
     "normalizeEffectPrefix",
-    "resolveEffectApiId",
     "toOperationContractSources"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {