@bleedingdev/modern-js-plugin-bff-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/dist/cjs/backend-federation-manifest/remote.js

@@ -63,13 +63,7 @@ function resolveBackendFederationRemoteFromManifest(manifest, remoteOverride = {
         ...verification ? {
             verification
         } : {},
-        ...remoteOverride.entryGlobalName ? {
-            entryGlobalName: remoteOverride.entryGlobalName
-        } : {},
-        expose,
-        ...remoteOverride.shareScope ? {
-            shareScope: remoteOverride.shareScope
-        } : {}
+        expose
     };
 }
 exports.resolveBackendFederationRemoteFromManifest = __webpack_exports__.resolveBackendFederationRemoteFromManifest;

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

@@ -34,6 +34,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const index_js_namespaceObject = require("../backend-federation/index.js");
+const identity_js_namespaceObject = require("../backend-federation/identity.js");
 const external_errors_js_namespaceObject = require("./errors.js");
 const external_metadata_js_namespaceObject = require("./metadata.js");
 function resolveExpectedBuildMarker(expected) {
@@ -76,19 +77,22 @@ 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');
+    const compatibility = (0, identity_js_namespaceObject.backendFederationCompatibility)(loaded);
     (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.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.unitId), manifestUnitId, 'deliveryUnit.unitId vs expose compatibility.unitId');
-    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), manifestBuildMarker, 'deliveryUnit.buildMarker vs expose compatibility.build');
+    const issues = (0, identity_js_namespaceObject.validateBackendFederationCompatibility)(compatibility, {
+        contractVersion: (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.contractVersion),
+        nodeAdapterVersion: (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.nodeAdapterVersion),
+        packageName: (0, external_metadata_js_namespaceObject.stringValue)(boundary?.packageName),
+        unitId: manifestUnitId,
+        build: manifestBuildMarker ?? (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion)
+    });
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'expose buildVersion');
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(0 === issues.length, 'version_mismatch', `[BFF][Effect] ${(0, identity_js_namespaceObject.formatBackendFederationIdentityIssues)(issues)}.`);
 }
 function classifyLoadError(error) {
     const message = error instanceof Error ? error.message : String(error);

package/dist/cjs/cross-project-policy/node.js

@@ -1,14 +1,5 @@
 "use strict";
 var __webpack_require__ = {};
-(()=>{
-    __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)=>{
@@ -39,33 +30,22 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     resolveAdapterCrossProjectPolicy: ()=>resolveAdapterCrossProjectPolicy
 });
-const external_node_fs_namespaceObject = require("node:fs");
-const external_node_path_namespaceObject = require("node:path");
-var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 require("@modern-js/server-runtime-extensions/server-config");
 const node_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy/node");
-const readNearestPackageVersion = (startDir)=>{
-    if (!startDir) return;
-    let current = external_node_path_default().resolve(startDir);
-    for(let depth = 0; depth < 10; depth += 1){
-        try {
-            const packageJson = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(external_node_path_default().join(current, 'package.json'), 'utf8'));
-            if ('string' == typeof packageJson.version) return packageJson.version;
-        } catch  {}
-        const parent = external_node_path_default().dirname(current);
-        if (parent === current) break;
-        current = parent;
-    }
-};
-const resolveAdapterCrossProjectPolicy = (api, handlers)=>{
+const resolveAdapterCrossProjectPolicy = (api, handlers, producer)=>{
     const bff = api.getServerConfig()?.bff;
     const { apiDirectory, appDirectory } = api.getServerContext();
     return (0, node_namespaceObject.resolveCrossProjectPolicy)({
         crossProjectPolicy: bff?.crossProjectPolicy,
         handlers,
-        requestId: bff?.requestId,
         isCrossProjectServer: bff?.isCrossProjectServer,
-        operationVersion: (0, node_namespaceObject.deriveOperationVersion)(readNearestPackageVersion(apiDirectory) ?? readNearestPackageVersion(appDirectory))
+        ...producer ?? (0, node_namespaceObject.resolveOperationProducer)({
+            directories: [
+                apiDirectory,
+                appDirectory
+            ],
+            requestId: bff?.requestId || 'default'
+        })
     });
 };
 exports.resolveAdapterCrossProjectPolicy = __webpack_exports__.resolveAdapterCrossProjectPolicy;

package/dist/cjs/{effect-adapter → effect-server}/cross-project-policy.js

@@ -28,18 +28,18 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    resolveEffectAdapterCrossProjectPolicy: ()=>resolveEffectAdapterCrossProjectPolicy
+    resolveEffectServerCrossProjectPolicy: ()=>resolveEffectServerCrossProjectPolicy
 });
 const effect_namespaceObject = require("@modern-js/bff-effect/effect");
 const utils_namespaceObject = require("@modern-js/utils");
-const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const http_api_namespaceObject = require("effect/http-api");
 const index_js_namespaceObject = require("../cross-project-policy/index.js");
-function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
-    const contractSourcesPromise = null === mod ? Promise.resolve([]) : Promise.resolve().then(()=>(0, effect_namespaceObject.extractHttpApiFromModule)(mod, httpapi_namespaceObject.HttpApi.isHttpApi)).then((effectApi)=>{
+function resolveEffectServerCrossProjectPolicy(api, prefix, mod, producer) {
+    const contractSourcesPromise = null === mod ? Promise.resolve([]) : Promise.resolve().then(()=>(0, effect_namespaceObject.extractHttpApiFromModule)(mod, http_api_namespaceObject.HttpApi.isHttpApi)).then((effectApi)=>{
         if (null === effectApi) return [];
         const reflect = (apiValue, handlers)=>{
-            if (!httpapi_namespaceObject.HttpApi.isHttpApi(apiValue)) throw new Error('[BFF][Effect] Endpoint reflection received a non-HttpApi value.');
-            httpapi_namespaceObject.HttpApi.reflect(apiValue, {
+            if (!http_api_namespaceObject.HttpApi.isHttpApi(apiValue)) throw new Error('[BFF][Effect] Endpoint reflection received a non-HttpApi value.');
+            http_api_namespaceObject.HttpApi.reflect(apiValue, {
                 onGroup: handlers.onGroup ?? (()=>{}),
                 onEndpoint: handlers.onEndpoint
             });
@@ -50,14 +50,14 @@ function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
         return [];
     });
     return contractSourcesPromise.then((contractSources)=>{
-        const policy = (0, index_js_namespaceObject.resolveAdapterCrossProjectPolicy)(api, contractSources);
+        const policy = (0, index_js_namespaceObject.resolveAdapterCrossProjectPolicy)(api, contractSources, producer);
         if (policy?.enabled === true && 0 === contractSources.length) utils_namespaceObject.logger.warn('[BFF][Effect] Cross-project policy enabled but no HttpApi endpoints could be reflected; requests fail operation-contract matching unless allowUnknownOperations is enabled.');
         return policy;
     });
 }
-exports.resolveEffectAdapterCrossProjectPolicy = __webpack_exports__.resolveEffectAdapterCrossProjectPolicy;
+exports.resolveEffectServerCrossProjectPolicy = __webpack_exports__.resolveEffectServerCrossProjectPolicy;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "resolveEffectAdapterCrossProjectPolicy"
+    "resolveEffectServerCrossProjectPolicy"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/effect-server/entry.js

@@ -0,0 +1,63 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveEffectServerEntryFile: ()=>resolveEffectServerEntryFile
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+require("@modern-js/server-runtime-extensions/server-config");
+const utils_namespaceObject = require("@modern-js/utils");
+const paths_js_namespaceObject = require("../effect-source-loader/paths.js");
+function resolveEffectServerEntryFile(api) {
+    const { appDirectory, apiDirectory, distDirectory } = api.getServerContext();
+    const appDir = external_node_path_default().resolve(appDirectory || process.cwd());
+    return (0, paths_js_namespaceObject.resolveEffectEntry)({
+        appDir,
+        apiDir: external_node_path_default().resolve(appDir, apiDirectory || utils_namespaceObject.API_DIR),
+        effectEntry: api.getServerConfig()?.bff?.effect?.entry,
+        distDir: (0, utils_namespaceObject.isProd)() && distDirectory ? external_node_path_default().resolve(distDirectory) : void 0
+    }).path;
+}
+exports.resolveEffectServerEntryFile = __webpack_exports__.resolveEffectServerEntryFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveEffectServerEntryFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/{effect-adapter → effect-server}/error-response.js

@@ -28,11 +28,11 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    createEffectAdapterRuntimeErrorResponse: ()=>createEffectAdapterRuntimeErrorResponse
+    createEffectServerRuntimeErrorResponse: ()=>createEffectServerRuntimeErrorResponse
 });
 const safe_failure_namespaceObject = require("@modern-js/runtime-extensions/safe-failure");
 const utils_namespaceObject = require("@modern-js/utils");
-function createEffectAdapterRuntimeErrorResponse(api, error, context) {
+function createEffectServerRuntimeErrorResponse(api, error, context) {
     try {
         const onError = api.getServerConfig()?.onError;
         if (void 0 !== onError) return Promise.resolve(onError(error instanceof Error ? error : new Error(String(error)), ensureJsonContext(context))).then((result)=>result instanceof Response ? result : (0, safe_failure_namespaceObject.createSafeFailureResponse)(error)).catch((configError)=>{
@@ -66,9 +66,9 @@ function ensureJsonContext(context) {
         }
     });
 }
-exports.createEffectAdapterRuntimeErrorResponse = __webpack_exports__.createEffectAdapterRuntimeErrorResponse;
+exports.createEffectServerRuntimeErrorResponse = __webpack_exports__.createEffectServerRuntimeErrorResponse;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createEffectAdapterRuntimeErrorResponse"
+    "createEffectServerRuntimeErrorResponse"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/effect-server/index.js

@@ -0,0 +1,200 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>effect_server
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+require("@modern-js/server-runtime-extensions/server-config");
+const effect_namespaceObject = require("@modern-js/bff-effect/effect");
+const node_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy/node");
+const runtime_lifecycle_namespaceObject = require("@modern-js/server-runtime-extensions/runtime-lifecycle");
+const utils_namespaceObject = require("@modern-js/utils");
+const evaluation_js_namespaceObject = require("../cross-project-policy/evaluation.js");
+const loader_js_namespaceObject = require("../effect-source-loader/loader.js");
+const external_cross_project_policy_js_namespaceObject = require("./cross-project-policy.js");
+const external_entry_js_namespaceObject = require("./entry.js");
+const external_error_response_js_namespaceObject = require("./error-response.js");
+const EFFECT_MIDDLEWARE_BEFORE = [
+    'custom-server-hook',
+    'custom-server-middleware',
+    'render'
+];
+const effect_server = ()=>({
+        name: '@modern-js/plugin-bff-extensions/effect-server',
+        setup (api) {
+            const runtimeFramework = api.getServerContext().bffRuntimeFramework;
+            if ('effect' !== runtimeFramework) throw new Error(`Effect BFF server plugin requires Effect; received "${runtimeFramework}".`);
+            let handler = null;
+            let unregisterRuntimeDisposer;
+            let prefix = '/api';
+            let prefixes = [
+                '/api'
+            ];
+            let matchingPrefixes = [
+                '/api'
+            ];
+            let retired = false;
+            const dispose = async ()=>{
+                retired = true;
+                unregisterRuntimeDisposer?.();
+                unregisterRuntimeDisposer = void 0;
+                const previous = handler;
+                handler = null;
+                await previous?.dispose();
+            };
+            const loadHandler = async ()=>{
+                const entryFile = (0, external_entry_js_namespaceObject.resolveEffectServerEntryFile)(api);
+                if (!entryFile || !await utils_namespaceObject.fs.pathExists(entryFile)) {
+                    handler = null;
+                    return;
+                }
+                const { appDirectory } = api.getServerContext();
+                let mod;
+                try {
+                    mod = await ((0, utils_namespaceObject.isProd)() ? (0, loader_js_namespaceObject.loadEffectBuiltModule)(entryFile) : (0, loader_js_namespaceObject.loadEffectSourceModule)({
+                        resourcePath: entryFile,
+                        appDir: appDirectory || external_node_path_default().dirname(entryFile),
+                        globalVars: api.getServerConfig()?.source?.globalVars
+                    }));
+                } catch (error) {
+                    utils_namespaceObject.logger.error(`[BFF][Effect] Failed to load Effect entry: ${entryFile}\n${String(error)}`);
+                    throw error;
+                }
+                const producer = (0, node_namespaceObject.resolveOperationProducer)({
+                    directories: [
+                        external_node_path_default().dirname(entryFile),
+                        appDirectory
+                    ],
+                    requestId: api.getServerConfig()?.bff?.requestId
+                });
+                const crossProjectPolicies = new Map(await Promise.all(prefixes.map(async (prefix)=>[
+                        prefix,
+                        await (0, external_cross_project_policy_js_namespaceObject.resolveEffectServerCrossProjectPolicy)(api, prefix, mod, producer)
+                    ])));
+                const effectConfig = api.getServerConfig()?.bff?.effect;
+                const loaded = await (0, effect_namespaceObject.resolveEffectBffModuleHandler)(mod, {
+                    openapi: effectConfig?.openapi,
+                    dataPlatform: effectConfig?.dataPlatform,
+                    validateRequest: (request)=>{
+                        const { path: mountedPathname } = (0, effect_namespaceObject.useEffectContext)();
+                        const prefix = matchingPrefixes.find((item)=>'/' === item || mountedPathname === item || mountedPathname.startsWith(`${item}/`));
+                        if (!prefix) return null;
+                        const requestUrl = new URL(request.url);
+                        if ('/' !== prefix) requestUrl.pathname = '/' === requestUrl.pathname ? prefix : `${prefix}${requestUrl.pathname}`;
+                        return (0, evaluation_js_namespaceObject.checkCrossProjectPolicyForRequest)(new Request(requestUrl, request), crossProjectPolicies.get(prefix));
+                    },
+                    onWarning: (message)=>utils_namespaceObject.logger.warn(message)
+                });
+                if (!loaded) {
+                    const error = new Error(`[BFF][Effect] Invalid Effect entry module: ${entryFile}. Export defineEffectBff(...) or a { api, layer } HttpApi module.`);
+                    utils_namespaceObject.logger.warn(error.message);
+                    throw error;
+                }
+                const candidateOwner = {};
+                if (loaded.dispose) (0, runtime_lifecycle_namespaceObject.registerServerRuntimeDisposer)(candidateOwner, loaded.dispose);
+                const candidate = (0, runtime_lifecycle_namespaceObject.createDisposableServerRuntimeHandle)(candidateOwner, loaded.handler);
+                if (retired) {
+                    await candidate.dispose();
+                    throw new Error('Cannot initialize a retired Effect server.');
+                }
+                handler = candidate;
+            };
+            api.onPrepare(async ()=>{
+                const { middlewares: globalMiddlewares } = api.getServerContext();
+                const configuredPrefix = api.getServerConfig()?.bff?.prefix;
+                const enableHandleWeb = api.getServerConfig()?.bff?.enableHandleWeb;
+                const configuredPrefixes = Array.isArray(configuredPrefix) ? configuredPrefix.filter(Boolean) : [
+                    configuredPrefix || '/api'
+                ];
+                prefixes = [
+                    ...new Set(configuredPrefixes.length > 0 ? configuredPrefixes : [
+                        '/api'
+                    ])
+                ];
+                matchingPrefixes = [
+                    ...prefixes
+                ].sort((left, right)=>right.length - left.length);
+                prefix = prefixes[0] || '/api';
+                const { serverBase } = api.getServerContext();
+                if (serverBase) unregisterRuntimeDisposer = (0, runtime_lifecycle_namespaceObject.registerServerRuntimeDisposer)(serverBase, dispose);
+                try {
+                    await loadHandler();
+                } catch (error) {
+                    await dispose();
+                    throw error;
+                }
+                const middlewarePrefixes = enableHandleWeb ? [
+                    prefix
+                ] : matchingPrefixes;
+                const middlewares = middlewarePrefixes.map((middlewarePrefix)=>({
+                        name: 'effect-api-handler',
+                        path: enableHandleWeb ? '*' : `${middlewarePrefix}/*`,
+                        method: 'all',
+                        order: 'post',
+                        before: EFFECT_MIDDLEWARE_BEFORE,
+                        handler: async (context, next)=>{
+                            const activeHandler = handler;
+                            if (!activeHandler) {
+                                if (enableHandleWeb) return void await next();
+                                return (0, external_error_response_js_namespaceObject.createEffectServerRuntimeErrorResponse)(api, new Error('[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.'), context);
+                            }
+                            const mountedPrefix = enableHandleWeb ? matchingPrefixes.find((item)=>'/' === item || context.req.path === item || context.req.path.startsWith(`${item}/`)) || prefix : middlewarePrefix;
+                            const response = await (0, effect_namespaceObject.dispatchEffectBffRequest)(activeHandler, context.req.raw, {
+                                prefix: mountedPrefix,
+                                env: context.env,
+                                path: context.req.path,
+                                method: context.req.method,
+                                onError: (error)=>(0, external_error_response_js_namespaceObject.createEffectServerRuntimeErrorResponse)(api, error, context)
+                            });
+                            if (404 === response.status && enableHandleWeb) return void await next();
+                            return new Response(response.body, response);
+                        }
+                    }));
+                globalMiddlewares.push(...middlewares);
+            });
+        }
+    });
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect-source-loader/built-entry.js

@@ -34,12 +34,11 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const utils_namespaceObject = require("@modern-js/utils");
 const external_paths_js_namespaceObject = require("./paths.js");
-const BUILT_ENTRY_EXT = /\.(?:[cm]?ts|tsx|jsx)$/u;
 function resolveBuiltEffectEntry(appDirectory, distDirectory, sourceEntry) {
     if (void 0 === sourceEntry || 0 === sourceEntry.length) return;
-    const relativeEntry = utils_namespaceObject.upath.relative(appDirectory, sourceEntry);
-    if ('..' === relativeEntry || relativeEntry.startsWith(`..${utils_namespaceObject.upath.sep}`)) throw new Error(`Effect BFF entry must be inside the application directory: ${sourceEntry}`);
-    const builtEntry = utils_namespaceObject.upath.resolve(distDirectory, relativeEntry).replace(BUILT_ENTRY_EXT, '.js');
+    const relativeEntry = (0, external_paths_js_namespaceObject.relativeEffectAppPath)(appDirectory, sourceEntry);
+    if (void 0 === relativeEntry) throw new Error(`Effect BFF entry must be inside the application directory: ${sourceEntry}`);
+    const builtEntry = (0, external_paths_js_namespaceObject.emittedEffectEntry)(utils_namespaceObject.upath.resolve(distDirectory, relativeEntry));
     return utils_namespaceObject.fs.existsSync(builtEntry) ? builtEntry : void 0;
 }
 async function bundleBuiltEffectEntryForNode(options) {
@@ -65,7 +64,7 @@ function resolveEffectEntryPaths(options) {
         apiDir,
         effectEntry
     });
-    const relativeEffectEntry = void 0 !== sourceEffectEntry && sourceEffectEntry.length > 0 ? utils_namespaceObject.upath.relative(appDir, sourceEffectEntry).replace(BUILT_ENTRY_EXT, '.js') : '';
+    const relativeEffectEntry = void 0 !== sourceEffectEntry && sourceEffectEntry.length > 0 ? (0, external_paths_js_namespaceObject.emittedEffectEntry)(utils_namespaceObject.upath.relative(appDir, sourceEffectEntry)) : '';
     return {
         sourceEffectEntry,
         relativeEffectEntry

package/dist/cjs/effect-source-loader/http-api-runtime.js

@@ -32,14 +32,14 @@ __webpack_require__.d(__webpack_exports__, {
     loadEffectApi: ()=>loadEffectApi
 });
 const effect_namespaceObject = require("@modern-js/bff-effect/effect");
-const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const http_api_namespaceObject = require("effect/http-api");
 const external_loader_js_namespaceObject = require("./loader.js");
 function getHttpApiRuntime() {
     return Promise.resolve({
-        isHttpApi: httpapi_namespaceObject.HttpApi.isHttpApi,
+        isHttpApi: http_api_namespaceObject.HttpApi.isHttpApi,
         reflect: (api, handlers)=>{
-            if (!httpapi_namespaceObject.HttpApi.isHttpApi(api)) throw new TypeError('[BFF][Effect] Expected an HttpApi contract.');
-            httpapi_namespaceObject.HttpApi.reflect(api, {
+            if (!http_api_namespaceObject.HttpApi.isHttpApi(api)) throw new TypeError('[BFF][Effect] Expected an HttpApi contract.');
+            http_api_namespaceObject.HttpApi.reflect(api, {
                 onGroup: handlers.onGroup ?? (()=>{}),
                 onEndpoint: handlers.onEndpoint
             });

package/dist/cjs/effect-source-loader/loader.js

@@ -50,7 +50,8 @@ const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_node_url_namespaceObject = require("node:url");
 const external_esbuild_namespaceObject = require("esbuild");
-const NODE_TARGET = 'node26.7';
+const index_js_namespaceObject = require("../server-global-vars/index.js");
+const NODE_TARGET = 'node26.10';
 const SOURCE_LOADERS = new Map([
     [
         '.js',
@@ -125,6 +126,7 @@ const nodeBuiltins = new Set([
     ...external_node_module_namespaceObject.builtinModules.map((name)=>`node:${name}`)
 ]);
 const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
+const BFF_RUNTIME_PACKAGE = /^@modern-js\/(?:bff-effect|plugin-bff)(?:\/|$)/;
 async function isEsmOnlyFile(filename) {
     const extension = external_node_path_default().extname(filename).toLowerCase();
     if ('.mjs' === extension || '.mts' === extension) return true;
@@ -153,6 +155,10 @@ function externalizeInstalledDependencies(options) {
             buildApi.onResolve({
                 filter: /.*/
             }, async (args)=>{
+                if (BFF_RUNTIME_PACKAGE.test(args.path)) return {
+                    external: true,
+                    path: args.path
+                };
                 if (!isBareSpecifier(args.path) || nodeBuiltins.has(args.path) || args.pluginData?.[dependencyResolutionMarker] === true) return nodeBuiltins.has(args.path) ? {
                     external: true,
                     path: args.path
@@ -176,7 +182,8 @@ function externalizeInstalledDependencies(options) {
                     path: args.path
                 };
                 const realPath = await external_node_fs_default().promises.realpath(resolution.path).catch(()=>resolution.path);
-                if (realPath.includes(`${external_node_path_default().sep}node_modules${external_node_path_default().sep}`)) {
+                const loader = SOURCE_LOADERS.get(external_node_path_default().extname(realPath).toLowerCase());
+                if (realPath.includes(`${external_node_path_default().sep}node_modules${external_node_path_default().sep}`) && 'ts' !== loader && 'tsx' !== loader && 'jsx' !== loader) {
                     const runtimeResolution = await buildApi.resolve(args.path, {
                         importer: '',
                         kind: args.kind,
@@ -279,6 +286,7 @@ async function loadEffectSourceModule(options) {
             js: `import { createRequire as __modernCreateEffectRequire } from 'node:module'; const require = __modernCreateEffectRequire(${JSON.stringify((0, external_node_url_namespaceObject.pathToFileURL)(resourcePath).href)});`
         },
         bundle: true,
+        define: (0, index_js_namespaceObject.serializeServerGlobalVars)(options.globalVars),
         entryPoints: [
             resourcePath
         ],

package/dist/cjs/effect-source-loader/operation-contracts.js

@@ -34,44 +34,21 @@ const effect_namespaceObject = require("@modern-js/bff-effect/effect");
 const node_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy/node");
 const utils_namespaceObject = require("@modern-js/utils");
 const external_http_api_runtime_js_namespaceObject = require("./http-api-runtime.js");
-function getPackageInfo(resourcePath, appDir, onDependency) {
-    for (const startDir of [
-        utils_namespaceObject.upath.dirname(resourcePath),
-        appDir
-    ]){
-        let current = utils_namespaceObject.upath.resolve(startDir);
-        for(let depth = 0; depth < 32; depth += 1){
-            const packageJsonPath = utils_namespaceObject.upath.join(current, 'package.json');
-            if (utils_namespaceObject.fs.existsSync(packageJsonPath)) {
-                onDependency?.(packageJsonPath);
-                try {
-                    const packageJson = utils_namespaceObject.fs.readJSONSync(packageJsonPath);
-                    return {
-                        name: packageJson.name,
-                        version: packageJson.version
-                    };
-                } catch  {
-                    return {};
-                }
-            }
-            const parent = utils_namespaceObject.upath.dirname(current);
-            if (parent === current) break;
-            current = parent;
-        }
-    }
-    return {};
-}
 async function resolveEffectOperationContracts(options) {
     const api = await (0, external_http_api_runtime_js_namespaceObject.loadEffectApi)(options);
     if (null === api) return null;
     const runtime = await (0, external_http_api_runtime_js_namespaceObject.getHttpApiRuntime)();
     const endpoints = (0, effect_namespaceObject.collectEffectEndpoints)(runtime.reflect, api, options.prefix);
-    const packageInfo = getPackageInfo(options.resourcePath, options.appDir, options.onDependency);
-    const requestId = options.requestId?.trim() || packageInfo.name || 'default';
     return (0, node_namespaceObject.buildOperationContractMap)({
         handlers: (0, effect_namespaceObject.toOperationContractSources)(endpoints),
-        requestId,
-        operationVersion: (0, node_namespaceObject.deriveOperationVersion)(packageInfo.version)
+        ...(0, node_namespaceObject.resolveOperationProducer)({
+            directories: [
+                utils_namespaceObject.upath.dirname(options.resourcePath),
+                options.appDir
+            ],
+            requestId: options.requestId,
+            onDependency: options.onDependency
+        })
     });
 }
 exports.resolveEffectOperationContracts = __webpack_exports__.resolveEffectOperationContracts;