@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

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

@@ -1,5 +1,28 @@
 "use strict";
-var __webpack_require__ = {};
+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)=>{
@@ -26,262 +49,14 @@ var __webpack_require__ = {};
     };
 })();
 var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT: ()=>BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT,
-    BackendFederationManifestAdapterError: ()=>BackendFederationManifestAdapterError,
-    loadBackendFederatedEffectApiFromManifest: ()=>loadBackendFederatedEffectApiFromManifest,
-    loadBackendFederationManifest: ()=>loadBackendFederationManifest,
-    resolveBackendFederationRemoteFromManifest: ()=>resolveBackendFederationRemoteFromManifest
-});
-const external_backend_federation_js_namespaceObject = require("./backend-federation.js");
-const BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT = 'modernjs:microvertical-server-fallback';
-class BackendFederationManifestAdapterError extends Error {
-    constructor(code, message, cause, details){
-        super(message), this.failureEvent = BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT;
-        this.name = 'BackendFederationManifestAdapterError';
-        this.code = code;
-        if (details) this.details = details;
-        if (void 0 !== cause) this.cause = cause;
-    }
-}
-function stringValue(value) {
-    return 'string' == typeof value && value.length > 0 ? value : void 0;
-}
-function isRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
-function recordField(value, field) {
-    const fieldValue = value?.[field];
-    return isRecord(fieldValue) ? fieldValue : void 0;
-}
-function assertManifestAdapter(condition, code, message) {
-    if (!condition) throw new BackendFederationManifestAdapterError(code, message);
-}
-function assertVersionValue(actual, expected, label, details) {
-    if (void 0 === expected) return;
-    if (actual !== expected) throw new BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation ${label} mismatch: expected ${expected}, received ${actual ?? 'undefined'}.`, void 0, {
-        label,
-        expected,
-        received: actual,
-        ...details
-    });
-}
-function assertConsistentValue(left, right, label, details) {
-    if (void 0 === left || void 0 === right || left === right) return;
-    throw new BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation ${label} mismatch: expected ${left}, received ${right}.`, void 0, {
-        label,
-        expected: left,
-        received: right,
-        ...details
-    });
-}
-function getProcessEnv() {
-    return "u" > typeof process ? process.env : void 0;
-}
-function resolveManifestReference(options) {
-    if (options.manifestPath) return options.manifestPath;
-    if (options.manifestUrl) return options.manifestUrl;
-    if (!options.manifestEnv) return;
-    return options.env?.[options.manifestEnv] ?? getProcessEnv()?.[options.manifestEnv];
-}
-function isHttpUrl(value) {
-    return /^https?:\/\//iu.test(value);
-}
-async function readFileReference(reference) {
-    const [{ fileURLToPath }, fs] = await Promise.all([
-        import("node:url"),
-        import("node:fs/promises")
-    ]);
-    const filePath = reference.startsWith('file:') ? fileURLToPath(reference) : reference;
-    return fs.readFile(filePath, 'utf8');
-}
-async function withTimeout(promise, timeoutMs, label) {
-    if (!timeoutMs || timeoutMs <= 0) return promise;
-    let timeout;
-    try {
-        return await Promise.race([
-            promise,
-            new Promise((_, reject)=>{
-                timeout = setTimeout(()=>{
-                    reject(new BackendFederationManifestAdapterError('timeout', `[BFF][Effect] ${label} timed out after ${timeoutMs}ms.`));
-                }, timeoutMs);
-            })
-        ]);
-    } finally{
-        if (timeout) clearTimeout(timeout);
-    }
-}
-function resolveRemoteEntryFromMetadata(manifest) {
-    const metaData = recordField(manifest, 'metaData');
-    const remoteEntry = recordField(metaData, 'remoteEntry');
-    const publicPath = stringValue(metaData?.publicPath) ?? stringValue(metaData?.ssrPublicPath);
-    const entryName = stringValue(remoteEntry?.name);
-    if (!publicPath || !entryName) return;
-    const entryPath = stringValue(remoteEntry?.path) ?? '';
-    const normalizedBase = publicPath.replace(/\/+$/u, '');
-    const normalizedPath = entryPath.replace(/^\/+|\/+$/gu, '');
-    return [
-        normalizedBase,
-        normalizedPath,
-        entryName
-    ].filter(Boolean).join('/');
-}
-function backendFederationMetadata(manifest) {
-    return recordField(manifest, 'backendFederation');
-}
-function versionBoundaryMetadata(manifest) {
-    return recordField(backendFederationMetadata(manifest), 'versionBoundary');
-}
-function deliveryUnitMetadata(record) {
-    return recordField(record, 'deliveryUnit');
-}
-function manifestDeliveryUnit(backendFederation, boundary) {
-    return {
-        boundary: deliveryUnitMetadata(boundary),
-        top: deliveryUnitMetadata(backendFederation)
-    };
-}
-function resolveExpectedBuildMarker(expected) {
-    if (void 0 !== expected.buildVersion && void 0 !== expected.buildMarker && expected.buildVersion !== expected.buildMarker) throw new 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 = backendFederationMetadata(manifest);
-    assertManifestAdapter(backendFederation, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare backendFederation metadata.');
-    assertManifestAdapter('effect' === backendFederation.runtimeFramework, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare runtimeFramework: "effect".');
-    assertManifestAdapter(true === backendFederation.strictEffectApproach, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare strictEffectApproach: true.');
-    assertVersionValue(stringValue(backendFederation.contractVersion), expected.contractVersion ?? external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_CONTRACT_VERSION, 'manifest contractVersion');
-    assertVersionValue(stringValue(backendFederation.nodeAdapterVersion), expected.nodeAdapterVersion ?? external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_NODE_ADAPTER_VERSION, 'manifest nodeAdapterVersion');
-    const boundary = versionBoundaryMetadata(manifest);
-    assertVersionValue(stringValue(backendFederation.name) ?? stringValue(manifest.name) ?? stringValue(manifest.id), expected.remoteName, 'manifest remoteName');
-    assertVersionValue(stringValue(boundary?.packageName), expected.packageName, 'versionBoundary.packageName');
-    assertVersionValue(stringValue(boundary?.version), expected.version, 'versionBoundary.version');
-    assertVersionValue(stringValue(boundary?.buildVersion), expected.buildVersion, 'versionBoundary.buildVersion');
-    assertConsistentValue(stringValue(manifest.version), stringValue(boundary?.version), 'manifest versionBoundary.version');
-    assertConsistentValue(stringValue(manifest.buildVersion), stringValue(boundary?.buildVersion), 'manifest versionBoundary.buildVersion');
-    const deliveryUnit = manifestDeliveryUnit(backendFederation, boundary);
-    assertConsistentValue(stringValue(deliveryUnit.boundary?.buildMarker), stringValue(boundary?.buildVersion), 'versionBoundary.deliveryUnit.buildMarker vs versionBoundary.buildVersion');
-    assertConsistentValue(stringValue(deliveryUnit.top?.unitId), stringValue(deliveryUnit.boundary?.unitId), 'backendFederation.deliveryUnit.unitId vs versionBoundary.deliveryUnit.unitId');
-    const manifestUnitId = stringValue(deliveryUnit.boundary?.unitId) ?? stringValue(deliveryUnit.top?.unitId);
-    assertVersionValue(manifestUnitId, expected.unitId, 'deliveryUnit.unitId');
-    assertVersionValue(stringValue(deliveryUnit.boundary?.buildMarker), expectedBuildMarker, 'deliveryUnit.buildMarker');
-}
-function validateLoadedBackendFederationContract(loaded, manifest, remote) {
-    const loadedContract = loaded.backendFederationContract;
-    const backendFederation = backendFederationMetadata(manifest);
-    const boundary = versionBoundaryMetadata(manifest);
-    const compatibility = recordField(loadedContract, 'compatibility');
-    assertManifestAdapter(compatibility, 'version_mismatch', `[BFF][Effect] Backend federation expose ${remote.name}/${remote.expose?.replace(/^\.\//u, '')} must declare compatibility metadata.`);
-    assertVersionValue(stringValue(loadedContract?.role), 'microvertical-server', 'expose role');
-    assertVersionValue(stringValue(loadedContract?.name), remote.name, 'expose name');
-    assertVersionValue(stringValue(compatibility.contractVersion), stringValue(backendFederation?.contractVersion), 'expose contractVersion');
-    assertVersionValue(stringValue(compatibility.nodeAdapterVersion), stringValue(backendFederation?.nodeAdapterVersion), 'expose nodeAdapterVersion');
-    assertVersionValue(stringValue(compatibility.packageName), stringValue(boundary?.packageName), 'expose packageName');
-    assertVersionValue(stringValue(compatibility.build), stringValue(boundary?.buildVersion), 'expose buildVersion');
-    const deliveryUnit = manifestDeliveryUnit(backendFederation, boundary);
-    const manifestUnitId = stringValue(deliveryUnit.boundary?.unitId) ?? stringValue(deliveryUnit.top?.unitId);
-    const manifestBuildMarker = stringValue(deliveryUnit.boundary?.buildMarker);
-    assertConsistentValue(manifestUnitId, stringValue(compatibility.unitId), 'deliveryUnit.unitId vs expose compatibility.unitId');
-    assertConsistentValue(manifestBuildMarker, stringValue(compatibility.build), 'deliveryUnit.buildMarker vs expose compatibility.build');
-}
-function classifyLoadError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes('strictEffectApproach') || message.includes('runtimeFramework')) return 'strict_effect_required';
-    return 'remote_unavailable';
-}
-async function loadBackendFederationManifest(options) {
-    if (options.manifest) return options.manifest;
-    const reference = resolveManifestReference(options);
-    if (!reference) throw new BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest reference is missing. Pass manifest, manifestPath, manifestUrl, or manifestEnv for ${external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE}.`);
-    try {
-        const source = isHttpUrl(reference) ? await (async ()=>{
-            const fetchManifest = options.fetch ?? globalThis.fetch;
-            if (!fetchManifest) throw new BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest ${reference} requires a fetch implementation.`);
-            const response = await withTimeout(fetchManifest(reference), options.timeoutMs, `Backend federation manifest ${reference}`);
-            if (!response.ok) throw new BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest ${reference} returned HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ''}.`);
-            return response.text();
-        })() : await withTimeout(readFileReference(reference), options.timeoutMs, `Backend federation manifest ${reference}`);
-        const manifest = JSON.parse(source);
-        assertManifestAdapter(isRecord(manifest), 'manifest_invalid', `[BFF][Effect] Backend federation manifest ${reference} must be a JSON object.`);
-        return manifest;
-    } catch (error) {
-        if (error instanceof BackendFederationManifestAdapterError) throw error;
-        throw new BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest ${reference} could not be loaded.`, error);
-    }
-}
-function resolveBackendFederationRemoteFromManifest(manifest, remoteOverride = {}) {
-    const backendFederation = backendFederationMetadata(manifest);
-    const entry = recordField(manifest, 'entry');
-    const metaData = recordField(manifest, 'metaData');
-    const remoteEntry = recordField(metaData, 'remoteEntry');
-    const remoteName = remoteOverride.name ?? stringValue(backendFederation?.name) ?? stringValue(manifest.name) ?? stringValue(manifest.id);
-    const remoteEntryUrl = remoteOverride.entry ?? stringValue(backendFederation?.containerEntry) ?? stringValue(entry?.url) ?? resolveRemoteEntryFromMetadata(manifest);
-    const remoteType = remoteOverride.type ?? stringValue(backendFederation?.remoteType) ?? stringValue(entry?.type) ?? stringValue(remoteEntry?.type) ?? 'module';
-    const expose = remoteOverride.expose ?? stringValue(backendFederation?.expose) ?? external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE;
-    assertManifestAdapter(remoteName, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare a remote name.');
-    assertManifestAdapter(remoteEntryUrl, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare a backend remote entry URL.');
-    assertManifestAdapter(expose === external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE, 'manifest_invalid', `[BFF][Effect] Backend federation manifest expose must be ${external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE}.`);
-    return {
-        name: remoteName,
-        entry: remoteEntryUrl,
-        type: remoteType,
-        ...remoteOverride.entryGlobalName ? {
-            entryGlobalName: remoteOverride.entryGlobalName
-        } : {},
-        expose,
-        ...remoteOverride.shareScope ? {
-            shareScope: remoteOverride.shareScope
-        } : {}
-    };
-}
-async function loadBackendFederatedEffectApiFromManifest(options) {
-    let manifest;
-    let remote;
-    try {
-        manifest = await loadBackendFederationManifest(options);
-        validateBackendFederationManifest(manifest, options.expected);
-        remote = resolveBackendFederationRemoteFromManifest(manifest, options.remote);
-        const loaded = await withTimeout((0, external_backend_federation_js_namespaceObject.loadBackendFederatedEffectApi)({
-            hostName: options.hostName,
-            remote,
-            ...options.plugins ? {
-                plugins: options.plugins
-            } : {},
-            ...options.runtime ? {
-                runtime: options.runtime
-            } : {}
-        }), options.timeoutMs, `Backend federation remote ${remote.name}`).catch((error)=>{
-            throw new BackendFederationManifestAdapterError(classifyLoadError(error), `[BFF][Effect] Backend federation remote ${remote?.name ?? 'unknown'} could not load ${remote?.expose ?? external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE}.`, error);
-        });
-        validateLoadedBackendFederationContract(loaded, manifest, remote);
-        return loaded;
-    } catch (error) {
-        const adapterError = error instanceof BackendFederationManifestAdapterError ? error : new BackendFederationManifestAdapterError('remote_unavailable', '[BFF][Effect] Backend federation manifest adapter failed.', error);
-        if (options.fallback) return options.fallback(adapterError, {
-            manifest,
-            remote
-        });
-        throw adapterError;
-    }
-}
-exports.BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT = __webpack_exports__.BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT;
-exports.BackendFederationManifestAdapterError = __webpack_exports__.BackendFederationManifestAdapterError;
-exports.loadBackendFederatedEffectApiFromManifest = __webpack_exports__.loadBackendFederatedEffectApiFromManifest;
-exports.loadBackendFederationManifest = __webpack_exports__.loadBackendFederationManifest;
-exports.resolveBackendFederationRemoteFromManifest = __webpack_exports__.resolveBackendFederationRemoteFromManifest;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT",
-    "BackendFederationManifestAdapterError",
-    "loadBackendFederatedEffectApiFromManifest",
-    "loadBackendFederationManifest",
-    "resolveBackendFederationRemoteFromManifest"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+(()=>{
+    __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

@@ -27,147 +27,19 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-const BACKEND_FEDERATION_EFFECT_EXPOSE = './effect-api';
-const BACKEND_FEDERATION_MANIFEST_FILE = 'backend-mf-manifest.json';
-const BACKEND_FEDERATION_CONTRACT_VERSION = 'microvertical-server-effect-v1';
-const BACKEND_FEDERATION_NODE_ADAPTER_VERSION = 'backend-mf-effect-v1';
-function normalizeExpose(expose) {
-    return expose.replace(/^\.\//u, '');
-}
-function exposeForRemoteRequest(expose) {
-    return `./${normalizeExpose(expose)}`;
-}
-function isRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
-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);
-    }
-    return remotes;
-}
-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('/'))
-    };
-}
-function decodeDataUrl(url) {
-    const commaIndex = url.indexOf(',');
-    if (commaIndex < 0) throw new Error('[BFF][Effect] Invalid backend federation data URL entry.');
-    return decodeURIComponent(url.slice(commaIndex + 1));
-}
-async function readCommonJsEntrySource(remote) {
-    if (remote.entry.startsWith('data:')) return decodeDataUrl(remote.entry);
-    if (remote.entry.startsWith('http://') || remote.entry.startsWith('https://')) {
-        const response = await fetch(remote.entry);
-        if (!response.ok) throw new Error(`[BFF][Effect] Failed to load backend federation remote ${remote.name}: ${response.status}`);
-        return response.text();
-    }
-    throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} cannot load CommonJS entry ${remote.entry}.`);
-}
-function evaluateCommonJsEntry(remote, source) {
-    const module = {
-        exports: {}
-    };
-    const exports1 = module.exports;
-    const evaluate = new Function('module', 'exports', 'globalThis', source);
-    evaluate(module, exports1, globalThis);
-    const entry = module.exports.default ?? module.exports;
-    if (!isRecord(entry)) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} entry must load object module.`);
-    return entry;
-}
-async function importModuleEntry(remote) {
-    const entry = await import(remote.entry);
-    return entry.default ?? entry;
-}
-async function resolvePluginEntry(remote, plugins) {
-    for (const plugin of plugins ?? []){
-        const loadEntry = plugin.loadEntry;
-        if ('function' != typeof loadEntry) continue;
-        const entry = await loadEntry({
-            remoteInfo: remote
-        });
-        if (entry) return entry;
-    }
-}
-async function loadBackendFederationEntry(remote, plugins) {
-    const pluginEntry = await resolvePluginEntry(remote, plugins);
-    if (pluginEntry) return pluginEntry;
-    if (remote.entryGlobalName) {
-        const globalEntry = globalThis[remote.entryGlobalName];
-        if (isRecord(globalEntry)) return globalEntry;
-    }
-    if ('module' === remote.type || remote.entry.startsWith('file:')) return importModuleEntry(remote);
-    return evaluateCommonJsEntry(remote, await readCommonJsEntrySource(remote));
-}
-async function loadBackendFederationExpose(remote, expose, options) {
-    const entry = await loadBackendFederationEntry(remote, options.plugins);
-    if ('function' == typeof entry.init) await entry.init({
-        hostName: options.hostName
-    });
-    if ('function' != typeof entry.get) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} entry must expose get().`);
-    const factory = await entry.get(expose);
-    if ('function' != typeof factory) throw new Error(`[BFF][Effect] Backend federation expose ${remote.name}/${normalizeExpose(expose)} must load factory function.`);
-    return factory();
-}
-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);
-        }
-    };
-}
-function createBackendFederationLoadEntryPlugin(options) {
-    return {
-        name: 'modernjs-backend-federation-load-entry',
-        async loadEntry ({ remoteInfo }) {
-            return options.resolveEntry({
-                name: remoteInfo.name,
-                entry: remoteInfo.entry,
-                type: remoteInfo.type,
-                entryGlobalName: remoteInfo.entryGlobalName,
-                shareScope: remoteInfo.shareScope
-            });
-        }
-    };
-}
-async function loadBackendFederatedEffectApi(options) {
-    const remoteName = options.remote?.name ?? options.remoteName;
-    if (!remoteName) throw new Error('[BFF][Effect] Missing backend federation remote name.');
-    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.`);
-    return loaded;
-}
 __webpack_require__.d(__webpack_exports__, {
-    createBackendFederationLoadEntryPlugin: ()=>createBackendFederationLoadEntryPlugin,
-    createBackendFederationRuntime: ()=>createBackendFederationRuntime,
-    loadBackendFederatedEffectApi: ()=>loadBackendFederatedEffectApi
-}, {
-    BACKEND_FEDERATION_CONTRACT_VERSION: BACKEND_FEDERATION_CONTRACT_VERSION,
-    BACKEND_FEDERATION_EFFECT_EXPOSE: BACKEND_FEDERATION_EFFECT_EXPOSE,
-    BACKEND_FEDERATION_MANIFEST_FILE: BACKEND_FEDERATION_MANIFEST_FILE,
-    BACKEND_FEDERATION_NODE_ADAPTER_VERSION: BACKEND_FEDERATION_NODE_ADAPTER_VERSION
+    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
 });
+const universal_namespaceObject = require("@modern-js/utils/universal");
+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;

package/dist/cjs/runtime/effect/handler/batch-handler.js

@@ -0,0 +1,161 @@
+"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__, {
+    createDataPlatformBatchRequestHandler: ()=>createDataPlatformBatchRequestHandler
+});
+const index_js_namespaceObject = require("../../data-platform/index.js");
+const external_batch_js_namespaceObject = require("./batch.js");
+const external_routing_js_namespaceObject = require("./routing.js");
+function createDataPlatformBatchRequestHandler(options) {
+    const dataPlatformBatchOptions = options.dataPlatform?.batch;
+    const batchEnabled = dataPlatformBatchOptions?.enabled !== false;
+    const batchPath = (0, external_batch_js_namespaceObject.normalizeBatchPath)(dataPlatformBatchOptions?.endpoint);
+    const batchMaxSize = Math.max(1, dataPlatformBatchOptions?.maxBatchSize ?? 16);
+    const batchMaxBytes = Math.max(1024, dataPlatformBatchOptions?.maxBatchBytes ?? 65536);
+    const batchConcurrency = Math.max(1, dataPlatformBatchOptions?.maxConcurrency ?? 4);
+    const batchItemTimeoutMs = Math.max(0, dataPlatformBatchOptions?.requestTimeoutMs ?? 10000);
+    const batchAllowedMethods = (0, external_batch_js_namespaceObject.normalizeBatchAllowedMethods)(dataPlatformBatchOptions?.allowedMethods);
+    const envelopeHeader = options.dataPlatform?.envelopeHeader || index_js_namespaceObject.DEFAULT_DATA_ENVELOPE_HEADER;
+    const normalizedEnvelopeHeader = envelopeHeader.toLowerCase();
+    const handle = async (request, context)=>{
+        const mountedPrefix = (0, external_routing_js_namespaceObject.getMountedPrefixFromContext)(request, context);
+        const method = (0, external_batch_js_namespaceObject.normalizeItemMethod)(request.method);
+        if ('POST' !== method) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)('Batch endpoint only supports POST requests', 405);
+        const contentType = request.headers.get('content-type') || '';
+        if (!contentType.includes('application/json')) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)('Batch endpoint requires application/json content-type', 415);
+        const payloadText = await request.text();
+        if ((0, external_batch_js_namespaceObject.toTextLength)(payloadText) > batchMaxBytes) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)(`Batch payload exceeds max size (${String(batchMaxBytes)} bytes)`, 413);
+        let payload;
+        try {
+            payload = JSON.parse(payloadText);
+        } catch  {
+            return (0, external_batch_js_namespaceObject.createBatchValidationResponse)('Invalid batch payload JSON');
+        }
+        if (!(0, external_batch_js_namespaceObject.isBatchRequestPayload)(payload)) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)('Invalid batch payload shape');
+        if (0 === payload.items.length) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)('Batch payload items cannot be empty');
+        if (payload.items.length > batchMaxSize) return (0, external_batch_js_namespaceObject.createBatchValidationResponse)(`Batch item count exceeds max size (${String(batchMaxSize)})`, 413);
+        const responseItems = await (0, external_batch_js_namespaceObject.mapWithConcurrency)(payload.items, batchConcurrency, async (rawItem, index)=>{
+            const fallbackId = `item_${String(index)}`;
+            const itemId = (0, external_batch_js_namespaceObject.isPlainObject)(rawItem) && 'string' == typeof rawItem.id ? rawItem.id : fallbackId;
+            if (!(0, external_batch_js_namespaceObject.isPlainObject)(rawItem)) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Invalid batch item; expected object');
+            if ('string' != typeof rawItem.path || 0 === rawItem.path.length) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Invalid batch item path');
+            if (!rawItem.path.startsWith('/')) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Batch item path must start with "/"');
+            const normalizedItemPath = (0, external_routing_js_namespaceObject.removeMountedPrefixFromBatchPath)(rawItem.path, mountedPrefix);
+            const itemPathname = normalizedItemPath.split('?')[0] || normalizedItemPath;
+            if (itemPathname === batchPath || itemPathname.startsWith(`${batchPath}/`)) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Batch item path cannot target batch endpoint');
+            const itemMethod = (0, external_batch_js_namespaceObject.normalizeItemMethod)('string' == typeof rawItem.method ? rawItem.method : void 0);
+            if (!batchAllowedMethods.has(itemMethod)) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 405, `Batch item method ${itemMethod} is not allowed`);
+            if (void 0 !== rawItem.body && null !== rawItem.body && 'string' != typeof rawItem.body) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Batch item body must be a string when provided');
+            if (('GET' === itemMethod || 'HEAD' === itemMethod) && 'string' == typeof rawItem.body) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, `${itemMethod} batch item cannot include body`);
+            const normalizedHeaders = {};
+            if (void 0 !== rawItem.headers) {
+                if (!(0, external_batch_js_namespaceObject.isPlainObject)(rawItem.headers)) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, 'Batch item headers must be an object');
+                for (const [key, value] of Object.entries(rawItem.headers)){
+                    if ('string' != typeof value) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 400, `Invalid header "${key}" for batch item`);
+                    normalizedHeaders[key.toLowerCase()] = value;
+                }
+            }
+            if (!normalizedHeaders.traceparent) {
+                const encodedEnvelope = normalizedHeaders[normalizedEnvelopeHeader];
+                if ('string' == typeof encodedEnvelope) {
+                    const envelope = (0, index_js_namespaceObject.decodeRequestEnvelopeHeader)(encodedEnvelope);
+                    if (envelope?.traceparent) normalizedHeaders.traceparent = envelope.traceparent;
+                }
+            }
+            if (!normalizedHeaders.traceparent) {
+                const requestTraceparent = request.headers.get('traceparent');
+                if (requestTraceparent) normalizedHeaders.traceparent = requestTraceparent;
+            }
+            const targetUrl = new URL(normalizedItemPath, request.url);
+            const requestHeaders = new Headers(normalizedHeaders);
+            const body = 'GET' === itemMethod || 'HEAD' === itemMethod ? void 0 : rawItem.body;
+            if (void 0 === body) requestHeaders.delete('content-type');
+            const itemRequest = new Request(targetUrl.toString(), {
+                method: itemMethod,
+                headers: requestHeaders,
+                body
+            });
+            try {
+                const itemResponse = await (0, external_batch_js_namespaceObject.promiseWithTimeout)(options.handleItem(itemRequest, context), batchItemTimeoutMs);
+                if (!(itemResponse instanceof Response)) return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 500, 'Invalid response returned by batch item handler');
+                const bodyText = await itemResponse.text();
+                const responseItem = {
+                    id: itemId,
+                    status: itemResponse.status,
+                    headers: (0, external_batch_js_namespaceObject.toHeaderRecord)(itemResponse.headers),
+                    ...bodyText ? {
+                        body: bodyText
+                    } : {}
+                };
+                return responseItem;
+            } catch (error) {
+                if (error instanceof Response) {
+                    const bodyText = await error.text();
+                    return {
+                        id: itemId,
+                        status: error.status,
+                        headers: (0, external_batch_js_namespaceObject.toHeaderRecord)(error.headers),
+                        ...bodyText ? {
+                            body: bodyText
+                        } : {}
+                    };
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 500, message);
+            }
+        });
+        const responsePayload = {
+            protocolVersion: 1,
+            batchId: payload.batchId,
+            receivedAt: Date.now(),
+            items: responseItems
+        };
+        return new Response(JSON.stringify(responsePayload), {
+            status: 200,
+            headers: {
+                'content-type': 'application/json; charset=utf-8',
+                [index_js_namespaceObject.DEFAULT_DATA_BATCH_HEADER]: '1',
+                'x-modernjs-data-batch-id': payload.batchId
+            }
+        });
+    };
+    return {
+        enabled: batchEnabled,
+        path: batchPath,
+        handle
+    };
+}
+exports.createDataPlatformBatchRequestHandler = __webpack_exports__.createDataPlatformBatchRequestHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDataPlatformBatchRequestHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});