@bleedingdev/modern-js-plugin-bff 3.4.0-ultramodern.9 → 3.5.0-ultramodern.1

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

@@ -39,7 +39,6 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     EffectAdapter: ()=>EffectAdapter
 });
-const bff_core_namespaceObject = require("@modern-js/bff-core");
 const utils_namespaceObject = require("@modern-js/utils");
 const httpapi_namespaceObject = require("effect/unstable/httpapi");
 const external_path_namespaceObject = require("path");
@@ -94,43 +93,12 @@ class EffectAdapter {
         const { appDirectory, apiDirectory } = this.api.getServerContext();
         const bffConfig = this.api.getServerConfig()?.bff;
         const configuredEntry = bffConfig?.effect?.entry;
-        const defaultEntry = external_path_default().resolve(appDirectory || process.cwd(), apiDirectory || utils_namespaceObject.API_DIR, 'effect', 'index');
-        const entryWithoutExt = configuredEntry ? external_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_path_default().resolve(appDirectory || process.cwd(), configuredEntry) : defaultEntry;
-        return resolveJsOrTsEntry(entryWithoutExt);
-    }
-    isApiRequestPath(requestPath, prefix, enableHandleWeb) {
-        if (!enableHandleWeb) return true;
-        const normalized = normalizePrefix(prefix);
-        if (!normalized) return true;
-        return requestPath === normalized || requestPath.startsWith(`${normalized}/`);
-    }
-    async collectLambdaContractSources() {
-        try {
-            const serverContext = this.api.getServerContext();
-            const appDir = serverContext.distDirectory || serverContext.appDirectory;
-            if (!appDir) return [];
-            const apiDir = 'string' == typeof serverContext.apiDirectory ? serverContext.apiDirectory : external_path_default().resolve(appDir, utils_namespaceObject.API_DIR);
-            const lambdaDir = 'string' == typeof serverContext.lambdaDirectory ? serverContext.lambdaDirectory : external_path_default().join(apiDir, 'lambda');
-            if (!await utils_namespaceObject.fs.pathExists(lambdaDir)) return [];
-            const apiRouter = new bff_core_namespaceObject.ApiRouter({
-                appDir,
-                apiDir,
-                lambdaDir,
-                prefix: this.prefix,
-                httpMethodDecider: this.api.getServerConfig()?.bff?.httpMethodDecider
-            });
-            const handlerInfos = await apiRouter.getApiHandlers();
-            return handlerInfos.map((info)=>({
-                    name: info.name,
-                    httpMethod: info.httpMethod,
-                    routePath: info.routePath,
-                    filename: info.filename,
-                    handler: info.handler
-                }));
-        } catch (error) {
-            utils_namespaceObject.logger.warn(`[BFF][Effect] Failed to derive lambda operation contracts for the cross-project policy: ${String(error)}`);
-            return [];
+        if (configuredEntry) {
+            const entryWithoutExt = external_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_path_default().resolve(appDirectory || process.cwd(), configuredEntry);
+            return resolveJsOrTsEntry(entryWithoutExt);
         }
+        const apiRoot = external_path_default().resolve(appDirectory || process.cwd(), apiDirectory || utils_namespaceObject.API_DIR);
+        return resolveJsOrTsEntry(external_path_default().resolve(apiRoot, 'index'));
     }
     async refreshCrossProjectPolicy(mod) {
         let contractSources = [];
@@ -146,24 +114,15 @@ class EffectAdapter {
         } catch (error) {
             utils_namespaceObject.logger.warn(`[BFF][Effect] Failed to reflect HttpApi endpoints for the cross-project policy: ${String(error)}`);
         }
-        let policy = (0, crossProjectServerPolicy_js_namespaceObject.resolveAdapterCrossProjectPolicy)(this.api, contractSources);
-        if (policy?.enabled) {
-            const lambdaSources = await this.collectLambdaContractSources();
-            if (lambdaSources.length > 0) {
-                contractSources = [
-                    ...contractSources,
-                    ...lambdaSources
-                ];
-                policy = (0, crossProjectServerPolicy_js_namespaceObject.resolveAdapterCrossProjectPolicy)(this.api, contractSources);
-            }
-        }
+        const policy = (0, crossProjectServerPolicy_js_namespaceObject.resolveAdapterCrossProjectPolicy)(this.api, contractSources);
         this.crossProjectPolicy = policy;
         if (this.crossProjectPolicy?.enabled && 0 === contractSources.length) utils_namespaceObject.logger.warn('[BFF][Effect] Cross-project policy is enabled but no HttpApi endpoints could be reflected; operation-contract matching is disabled for this server (envelope and operation-context checks still apply).');
     }
     async loadEffectHandlerFromModule(mod) {
+        const effectConfig = this.api.getServerConfig()?.bff?.effect;
         return (0, external_module_js_namespaceObject.resolveEffectBffModuleHandler)(mod, {
-            openapi: this.api.getServerConfig()?.bff?.effect?.openapi,
-            dataPlatform: this.api.getServerConfig()?.bff?.effect?.dataPlatform,
+            openapi: effectConfig?.openapi,
+            dataPlatform: effectConfig?.dataPlatform,
             validateRequest: (request)=>(0, crossProjectServerPolicy_js_namespaceObject.checkCrossProjectPolicyForRequest)(request, this.crossProjectPolicy),
             onWarning: (message)=>{
                 utils_namespaceObject.logger.warn(message);
@@ -197,13 +156,12 @@ class EffectAdapter {
         await this.refreshCrossProjectPolicy(mod);
         const loaded = await this.loadEffectHandlerFromModule(mod);
         if (!loaded) {
-            utils_namespaceObject.logger.warn(`[BFF][Effect] Invalid Effect entry module: ${entryFile}. Export { api, layer } or handler.`);
+            utils_namespaceObject.logger.warn(`[BFF][Effect] Invalid Effect entry module: ${entryFile}. Export defineEffectBff(...) or a { api, layer } HttpApi module.`);
             this.handler = null;
             return;
         }
         this.handler = loaded.handler;
         this.dispose = loaded.dispose || null;
-        this.policyEnforcedInMiddleware = !loaded.appliesRequestValidator;
     }
     async disposeCurrentHandler() {
         if (!this.dispose) return;
@@ -255,7 +213,6 @@ class EffectAdapter {
         this.handler = null;
         this.dispose = null;
         this.prefix = '/api';
-        this.policyEnforcedInMiddleware = false;
         this.registerMiddleware = async (options)=>{
             const { prefix, enableHandleWeb } = options;
             const { bffRuntimeFramework, middlewares: globalMiddlewares } = this.api.getServerContext();
@@ -266,7 +223,7 @@ class EffectAdapter {
             this.prefix = prefix || this.prefix;
             await this.reloadHandler();
             this.effectMiddleware = {
-                name: 'effect-bff-handler',
+                name: 'effect-api-handler',
                 path: enableHandleWeb ? '*' : `${prefix}/*`,
                 method: 'all',
                 order: 'post',
@@ -274,11 +231,7 @@ class EffectAdapter {
                 handler: async (c, next)=>{
                     if (!this.handler) {
                         if (enableHandleWeb) return void await next();
-                        return this.handleRuntimeError(new Error('[BFF][Effect] Missing Effect entry. Define api/effect/index or configure bff.effect.entry.'), c);
-                    }
-                    if (this.crossProjectPolicy?.enabled && this.policyEnforcedInMiddleware && this.isApiRequestPath(c.req.path, prefix, enableHandleWeb)) {
-                        const denial = (0, crossProjectServerPolicy_js_namespaceObject.checkCrossProjectPolicyForRequest)(c.req.raw, this.crossProjectPolicy);
-                        if (denial) return denial;
+                        return this.handleRuntimeError(new Error('[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.'), c);
                     }
                     let response;
                     try {

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

@@ -0,0 +1,81 @@
+"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__, {
+    createEffectOperationContext: ()=>external_operation_context_js_namespaceObject.createEffectOperationContext,
+    runWithEffectContext: ()=>runWithEffectContext,
+    useEffectContext: ()=>useEffectContext,
+    useOperationContext: ()=>useOperationContext
+});
+const external_operation_context_js_namespaceObject = require("./operation-context.js");
+const kEffectContext = Symbol.for('modernjs.plugin-bff.edgeEffectContext');
+const kEffectContextStorage = Symbol.for('modernjs.plugin-bff.edgeEffectContextStorage');
+const globalStore = globalThis;
+const isPromiseLike = (value)=>'object' == typeof value && null !== value && 'then' in value && 'function' == typeof value.then;
+const getRuntimeStorage = ()=>{
+    if (globalStore[kEffectContextStorage]) return globalStore[kEffectContextStorage];
+    if ('function' == typeof globalStore.AsyncLocalStorage) globalStore[kEffectContextStorage] = new globalStore.AsyncLocalStorage();
+    return globalStore[kEffectContextStorage];
+};
+const runWithEffectContext = (context, cb)=>{
+    const storage = getRuntimeStorage();
+    if (storage) return storage.run(context, cb);
+    const previous = globalStore[kEffectContext];
+    globalStore[kEffectContext] = context;
+    try {
+        const result = cb();
+        if (isPromiseLike(result)) return Promise.resolve(result).finally(()=>{
+            globalStore[kEffectContext] = previous;
+        });
+        globalStore[kEffectContext] = previous;
+        return result;
+    } catch (error) {
+        globalStore[kEffectContext] = previous;
+        throw error;
+    }
+};
+const useEffectContext = ()=>{
+    const context = getRuntimeStorage()?.getStore() ?? globalStore[kEffectContext];
+    if (!context) throw new Error("Can't call useEffectContext out of Effect runtime scope");
+    return context;
+};
+const useOperationContext = ()=>useEffectContext().operationContext;
+exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
+exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
+exports.useEffectContext = __webpack_exports__.useEffectContext;
+exports.useOperationContext = __webpack_exports__.useOperationContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEffectOperationContext",
+    "runWithEffectContext",
+    "useEffectContext",
+    "useOperationContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -3,6 +3,9 @@ var __webpack_modules__ = {
     "../safe-failure" (module) {
         module.exports = require("../safe-failure.js");
     },
+    "./edge-context" (module) {
+        module.exports = require("./edge-context.js");
+    },
     "./handler" (module) {
         module.exports = require("./handler.js");
     },
@@ -61,16 +64,21 @@ var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
     var _safe_failure__rspack_import_0 = __webpack_require__("../safe-failure");
-    var _module__rspack_import_1 = __webpack_require__("./module");
-    var _operation_context__rspack_import_2 = __webpack_require__("./operation-context");
-    var _handler__rspack_import_3 = __webpack_require__("./handler");
+    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 _handler__rspack_import_4 = __webpack_require__("./handler");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _handler__rspack_import_3)if ([
+    for(const __rspack_import_key in _handler__rspack_import_4)if ([
+        "runWithEffectContext",
+        "useEffectContext",
         "default",
-        "dispatchEffectBffRequest",
+        "useOperationContext",
         "createEffectOperationContext",
+        "dispatchEffectBffRequest",
+        "createEffectBffTestHandler",
         "createEffectBffEdgeHandler"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_3[__rspack_import_key];
+    ].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 '';
@@ -101,7 +109,7 @@ var __webpack_exports__ = {};
             env: options.env || {},
             path: originalPath,
             method,
-            operationContext: (0, _operation_context__rspack_import_2.createEffectOperationContext)({
+            operationContext: (0, _operation_context__rspack_import_3.createEffectOperationContext)({
                 request: effectRequest,
                 env: options.env || {},
                 path: originalPath,
@@ -120,7 +128,7 @@ var __webpack_exports__ = {};
         const effectRequest = createRequestForMountedPrefix(request, options.prefix);
         const effectContext = createEdgeEffectContext(request, effectRequest, options);
         try {
-            const response = handler.length > 1 ? await handler(effectRequest, effectContext) : await handler(effectRequest);
+            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) {
@@ -132,13 +140,14 @@ var __webpack_exports__ = {};
             return createRuntimeErrorResponse(error);
         }
     }
+    const createEffectBffTestHandler = createEffectBffEdgeHandler;
     async function createEffectBffEdgeHandler(options) {
-        const loaded = await (0, _module__rspack_import_1.resolveEffectBffModuleHandler)(options.module, {
+        const loaded = await (0, _module__rspack_import_2.resolveEffectBffModuleHandler)(options.module, {
             openapi: options.openapi,
             dataPlatform: options.dataPlatform,
             onWarning: options.onWarning
         });
-        if (!loaded) throw new Error('[BFF][Effect] Invalid Effect edge module. Export { api, layer }, createHandler, or handler.');
+        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, {
                     ...dispatchOptions,
@@ -152,17 +161,30 @@ var __webpack_exports__ = {};
     }
     __webpack_require__.d(__webpack_exports__, {
         createEffectBffEdgeHandler: ()=>createEffectBffEdgeHandler,
-        createEffectOperationContext: ()=>_operation_context__rspack_import_2.createEffectOperationContext,
-        dispatchEffectBffRequest: ()=>dispatchEffectBffRequest
+        createEffectOperationContext: ()=>_operation_context__rspack_import_3.createEffectOperationContext,
+        dispatchEffectBffRequest: ()=>dispatchEffectBffRequest,
+        runWithEffectContext: ()=>_edge_context__rspack_import_1.runWithEffectContext,
+        useEffectContext: ()=>_edge_context__rspack_import_1.useEffectContext,
+        useOperationContext: ()=>_edge_context__rspack_import_1.useOperationContext
+    }, {
+        createEffectBffTestHandler: createEffectBffTestHandler
     });
 })();
 exports.createEffectBffEdgeHandler = __webpack_exports__.createEffectBffEdgeHandler;
+exports.createEffectBffTestHandler = __webpack_exports__.createEffectBffTestHandler;
 exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
 exports.dispatchEffectBffRequest = __webpack_exports__.dispatchEffectBffRequest;
+exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
+exports.useEffectContext = __webpack_exports__.useEffectContext;
+exports.useOperationContext = __webpack_exports__.useOperationContext;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createEffectBffEdgeHandler",
+    "createEffectBffTestHandler",
     "createEffectOperationContext",
-    "dispatchEffectBffRequest"
+    "dispatchEffectBffRequest",
+    "runWithEffectContext",
+    "useEffectContext",
+    "useOperationContext"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -140,6 +140,8 @@ var __webpack_exports__ = {};
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_rpc__rspack_import_4[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
     const emptyEffectServiceContext = effect_Context__rspack_import_0.empty();
+    const isEffectServiceContext = (context)=>'object' == typeof context && null !== context && 'mapUnsafe' in context;
+    const toEffectServiceContext = (context)=>isEffectServiceContext(context) ? context : emptyEffectServiceContext;
     const EFFECT_VALIDATOR_AWARE_FACTORY = Symbol.for('modernjs.effect.validatorAware');
     function isValidatorAwareHandlerFactory(factory) {
         return 'function' == typeof factory && true === factory[EFFECT_VALIDATOR_AWARE_FACTORY];
@@ -457,7 +459,7 @@ var __webpack_exports__ = {};
     ]);
     function createLoaderMaterializedClientPlaceholder() {
         const explain = (property)=>{
-            throw new Error(`[BFF][Effect] effectBff.client.${String(property)} is not available here: the typed client only exists when this module is imported through the "@api/effect/*" transformed path (the BFF loader replaces it with generated client code). On the server, use HttpApiClient or call the Effect layer directly.`);
+            throw new Error(`[BFF][Effect] client.${String(property)} is not available here: the typed client only exists when the API entry is imported through the "@api/index" transformed path (the BFF loader replaces it with generated client code). On the server, use HttpApiClient or call the Effect layer directly.`);
         };
         return new Proxy(Object.create(null), {
             get (_target, property) {
@@ -498,7 +500,7 @@ var __webpack_exports__ = {};
             if (preparedRequest instanceof Response) return preparedRequest;
             const validationError = validateDataPlatformRequestEnvelope(preparedRequest, options.dataPlatform);
             if (validationError) return validationError;
-            return httpApiHandler.handler(preparedRequest, context ?? emptyEffectServiceContext);
+            return httpApiHandler.handler(preparedRequest, toEffectServiceContext(context));
         };
         const handleBatchRequest = async (request, context)=>{
             const mountedPrefix = getMountedPrefixFromContext(request, context);
@@ -620,7 +622,7 @@ var __webpack_exports__ = {};
                 if (isRpcRequest(request, rpcPath)) {
                     const policyDenial = options.validateRequest?.(request);
                     if (policyDenial) return policyDenial;
-                    return rpcHandler.handler(request, context ?? emptyEffectServiceContext);
+                    return rpcHandler.handler(request, toEffectServiceContext(context));
                 }
                 return handleHttpApiRequest(request);
             },

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

@@ -3,6 +3,9 @@ var __webpack_modules__ = {
     "./context" (module) {
         module.exports = require("./context.js");
     },
+    "./edge" (module) {
+        module.exports = require("./edge.js");
+    },
     "./handler" (module) {
         module.exports = require("./handler.js");
     },
@@ -59,30 +62,47 @@ var __webpack_exports__ = {};
     __webpack_require__.r(__webpack_exports__);
     var _effect_opentelemetry__rspack_import_0 = __webpack_require__("@effect/opentelemetry");
     var _context__rspack_import_1 = __webpack_require__("./context");
-    var _handler__rspack_import_2 = __webpack_require__("./handler");
+    var _edge__rspack_import_2 = __webpack_require__("./edge");
+    var _handler__rspack_import_3 = __webpack_require__("./handler");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _handler__rspack_import_2)if ([
+    for(const __rspack_import_key in _handler__rspack_import_3)if ([
+        "runWithEffectContext",
         "useEffectContext",
         "default",
-        "OpenTelemetry",
+        "useOperationContext",
         "createEffectOperationContext",
-        "useOperationContext"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_2[__rspack_import_key];
+        "dispatchEffectBffRequest",
+        "createEffectBffTestHandler",
+        "OpenTelemetry",
+        "createEffectBffEdgeHandler"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
     __webpack_require__.d(__webpack_exports__, {
         OpenTelemetry: ()=>_effect_opentelemetry__rspack_import_0,
+        createEffectBffEdgeHandler: ()=>_edge__rspack_import_2.createEffectBffEdgeHandler,
+        createEffectBffTestHandler: ()=>_edge__rspack_import_2.createEffectBffTestHandler,
         createEffectOperationContext: ()=>_context__rspack_import_1.createEffectOperationContext,
+        dispatchEffectBffRequest: ()=>_edge__rspack_import_2.dispatchEffectBffRequest,
+        runWithEffectContext: ()=>_context__rspack_import_1.runWithEffectContext,
         useEffectContext: ()=>_context__rspack_import_1.useEffectContext,
         useOperationContext: ()=>_context__rspack_import_1.useOperationContext
     });
 })();
 exports.OpenTelemetry = __webpack_exports__.OpenTelemetry;
+exports.createEffectBffEdgeHandler = __webpack_exports__.createEffectBffEdgeHandler;
+exports.createEffectBffTestHandler = __webpack_exports__.createEffectBffTestHandler;
 exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
+exports.dispatchEffectBffRequest = __webpack_exports__.dispatchEffectBffRequest;
+exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
 exports.useEffectContext = __webpack_exports__.useEffectContext;
 exports.useOperationContext = __webpack_exports__.useOperationContext;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "OpenTelemetry",
+    "createEffectBffEdgeHandler",
+    "createEffectBffTestHandler",
     "createEffectOperationContext",
+    "dispatchEffectBffRequest",
+    "runWithEffectContext",
     "useEffectContext",
     "useOperationContext"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

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

@@ -49,16 +49,18 @@ function isEffectServiceContext(context) {
     return 'object' == typeof context && null !== context && 'mapUnsafe' in context;
 }
 const emptyEffectServiceContext = Context_namespaceObject.empty();
+const strictEffectApproachMessage = '[BFF][Effect] strictEffectApproach is enforced: Effect API entries must export defineEffectBff(...) or a { api, layer } HttpApi module. Raw handler exports, default request handlers, and unbranded custom createHandler factories are not valid Effect API entries.';
+function rejectLegacyEffectModuleShape(options, shape) {
+    options.onWarning?.(`${strictEffectApproachMessage} Rejected ${shape}.`);
+    return true;
+}
 function callEffectBffRequestHandler(handler, request, context) {
     return void 0 === context ? handler(request) : handler(request, context);
 }
-function createLoadedHandler(webHandler, appliesRequestValidator) {
+function createLoadedHandler(webHandler) {
     return {
         handler: (request, context)=>callEffectBffRequestHandler(webHandler.handler, request, context),
-        dispose: webHandler.dispose,
-        ...appliesRequestValidator ? {
-            appliesRequestValidator: true
-        } : {}
+        dispose: webHandler.dispose
     };
 }
 function createLoadedHttpApiHandler(webHandler) {
@@ -67,18 +69,23 @@ function createLoadedHttpApiHandler(webHandler) {
             const effectContext = isEffectServiceContext(context) ? context : emptyEffectServiceContext;
             return webHandler.handler(request, effectContext);
         },
-        dispose: webHandler.dispose,
-        appliesRequestValidator: true
+        dispose: webHandler.dispose
     };
 }
 function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {}) {
-    if (isRequestHandler(normalizedModule.handler)) return {
-        handler: normalizedModule.handler
-    };
+    if (isRequestHandler(normalizedModule.handler)) {
+        if (rejectLegacyEffectModuleShape(options, '`handler` export')) return null;
+        return {
+            handler: normalizedModule.handler
+        };
+    }
     const entry = normalizedModule.default;
-    if (isRequestHandler(entry)) return {
-        handler: entry
-    };
+    if (isRequestHandler(entry)) {
+        if (rejectLegacyEffectModuleShape(options, 'default request handler')) return null;
+        return {
+            handler: entry
+        };
+    }
     if (isRecord(entry)) normalizedModule = {
         ...normalizedModule,
         ...entry
@@ -90,19 +97,22 @@ function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {})
             handler: maybeHandler
         };
     }
-    if (isRequestHandler(normalizedModule.handler)) return {
-        handler: normalizedModule.handler
-    };
+    if (isRequestHandler(normalizedModule.handler)) {
+        if (rejectLegacyEffectModuleShape(options, '`handler` export')) return null;
+        return {
+            handler: normalizedModule.handler
+        };
+    }
     if ('function' == typeof normalizedModule.createHandler) {
         const factory = normalizedModule.createHandler;
         const validatorAware = (0, external_handler_js_namespaceObject.isValidatorAwareHandlerFactory)(factory);
-        if (!validatorAware && void 0 !== options.validateRequest) options.onWarning?.('[BFF][Effect] Custom createHandler export detected: it cannot be verified to apply validateRequest (cross-project policy), so the policy is enforced by the adapter middleware on the outer request. Batched calls will be denied at the batch POST (it carries no per-operation contract); export defineEffectBff(...) to get per-batch-item enforcement.');
+        if (!validatorAware && rejectLegacyEffectModuleShape(options, 'unbranded `createHandler` export')) return null;
         const webHandler = factory({
             openapi: options.openapi,
             dataPlatform: options.dataPlatform,
             validateRequest: options.validateRequest
         });
-        return createLoadedHandler(webHandler, validatorAware);
+        return createLoadedHandler(webHandler);
     }
     if (isEffectApiDefinition(normalizedModule)) {
         options.onWarning?.('[BFF][Effect] Detected { api, layer } export without createHandler. Prefer `defineEffectBff(...)` from @modern-js/plugin-bff/server to avoid module instance mismatch.');
@@ -126,17 +136,26 @@ function resolveEffectBffModuleHandler(mod, options = {}) {
             ...value
         };
     };
-    if (isRequestHandler(normalizedModule.handler)) return Promise.resolve({
-        handler: normalizedModule.handler
-    });
+    if (isRequestHandler(normalizedModule.handler)) {
+        if (rejectLegacyEffectModuleShape(options, '`handler` export')) return Promise.resolve(null);
+        return Promise.resolve({
+            handler: normalizedModule.handler
+        });
+    }
     const entry = normalizedModule.default;
-    if (isRequestHandler(entry)) return Promise.resolve({
-        handler: entry
-    });
+    if (isRequestHandler(entry)) {
+        if (rejectLegacyEffectModuleShape(options, 'default request handler')) return Promise.resolve(null);
+        return Promise.resolve({
+            handler: entry
+        });
+    }
     if ('function' == typeof entry && 0 === entry.length) return Promise.resolve(entry()).then((out)=>{
-        if (isRequestHandler(out)) return {
-            handler: out
-        };
+        if (isRequestHandler(out)) {
+            if (rejectLegacyEffectModuleShape(options, 'default factory returning a request handler')) return null;
+            return {
+                handler: out
+            };
+        }
         mergeRuntimeExports(out);
         return resolveNormalizedEffectBffModuleHandler(normalizedModule, options);
     });

package/dist/cjs/utils/effectClientGenerator.js

@@ -172,14 +172,14 @@ const __generated = createGeneratedEffectClient(__manifest, __config, __requestR
 const client = __generated.client;
 const operationManifest = __generated.operationManifest;
 const createEffectRequestContext = __generated.createEffectRequestContext;
-const effectBffModule = {
+const apiModule = {
   client,
   operationManifest,
   createEffectRequestContext,
 };
 
 export { client, createEffectRequestContext, operationManifest };
-export default effectBffModule;
+export default apiModule;
 `;
 }
 function renderClientShape(endpoints, valueType) {
@@ -252,13 +252,13 @@ export declare const createEffectRequestContext: (
   requestContext: Record<string, unknown>,
 ) => EffectRequestContext;
 export declare const operationManifest: GeneratedEffectOperationManifest;
-declare const effectBffModule: {
+declare const apiModule: {
   client: GeneratedEffectClient;
   createEffectRequestContext: typeof createEffectRequestContext;
   operationManifest: GeneratedEffectOperationManifest;
 };
 
-export default effectBffModule;
+export default apiModule;
 `;
 }
 async function generateEffectClient(options) {
@@ -281,10 +281,15 @@ async function generateEffectClientCode(options) {
 }
 function resolveEffectEntryFile(options) {
     const { appDir, apiDir, effectEntry } = options;
-    const defaultEntry = external_path_default().resolve(apiDir, 'effect', 'index');
-    const entryWithoutExt = effectEntry ? external_path_default().isAbsolute(effectEntry) ? effectEntry : external_path_default().resolve(appDir, effectEntry) : defaultEntry;
-    if (external_path_default().extname(entryWithoutExt)) return utils_namespaceObject.fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
-    return (0, utils_namespaceObject.findExists)(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutExt}${ext}`));
+    const resolveEntry = (entryWithoutExt)=>{
+        if (external_path_default().extname(entryWithoutExt)) return utils_namespaceObject.fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
+        return (0, utils_namespaceObject.findExists)(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutExt}${ext}`));
+    };
+    if (effectEntry) {
+        const entryWithoutExt = external_path_default().isAbsolute(effectEntry) ? effectEntry : external_path_default().resolve(appDir, effectEntry);
+        return resolveEntry(entryWithoutExt);
+    }
+    return resolveEntry(external_path_default().resolve(apiDir, 'index'));
 }
 exports.generateEffectClient = __webpack_exports__.generateEffectClient;
 exports.generateEffectClientCode = __webpack_exports__.generateEffectClientCode;