@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.99 → 3.8.1-ultramodern.1

package/dist/esm-node/runtime/effect/backend-federation/load.mjs

@@ -3,27 +3,36 @@ import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "@modern-js/utils/universal";
 import { formatBackendFederationIdentityIssues, validateExpectedBackendFederationIdentity } from "./identity.mjs";
 import { createBackendFederationRuntime } from "./runtime.mjs";
 import { isRecord, normalizeExpose } from "./utils.mjs";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
+import * as __rspack_external_effect_Logger_1691a01b from "effect/Logger";
 const LEGACY_LOAD_WARNING = '[BFF][Effect] loadBackendFederatedEffectApi was called without an expected delivery-unit identity (expected.unitId + expected.buildMarker). Identity-less public backend loads are deprecated (ADR-0019/MV-G23) and will be rejected in a future major.';
-async function loadBackendFederatedEffectApi(options) {
+const legacyWarningLogger = __rspack_external_effect_Logger_1691a01b.withLeveledConsole(__rspack_external_effect_Logger_1691a01b.formatLogFmt);
+function warnLegacyLoad() {
+    __rspack_external_effect_Effect_41060786.runSync(__rspack_external_effect_Effect_41060786.provideService(__rspack_external_effect_Effect_41060786.logWarning(LEGACY_LOAD_WARNING), __rspack_external_effect_Logger_1691a01b.CurrentLoggers, new Set([
+        legacyWarningLogger
+    ])));
+}
+function loadBackendFederatedEffectApi(options) {
     const remoteName = options.remote?.name ?? options.remoteName;
-    if (!remoteName) throw new Error('[BFF][Effect] Missing backend federation remote name.');
-    if (void 0 === options.expected) console.warn(LEGACY_LOAD_WARNING);
+    if (void 0 === remoteName || 0 === remoteName.length) return Promise.reject(new Error('[BFF][Effect] Missing backend federation remote name.'));
+    if (void 0 === options.expected) warnLegacyLoad();
     const runtime = options.runtime ?? 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.`);
-    if (void 0 !== options.expected) {
-        const issues = validateExpectedBackendFederationIdentity(loaded, options.expected, {
-            allowMissingIdentityMetadata: true === options.allowMissingIdentityMetadata
-        });
-        if (issues.length > 0) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} delivery-unit identity mismatch: ${formatBackendFederationIdentityIssues(issues)}.`);
-    }
-    return loaded;
+    return runtime.loadRemote(remoteRequest).then((loaded)=>{
+        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.`);
+        if (void 0 !== options.expected) {
+            const issues = validateExpectedBackendFederationIdentity(loaded, options.expected, {
+                allowMissingIdentityMetadata: true === options.allowMissingIdentityMetadata
+            });
+            if (issues.length > 0) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} delivery-unit identity mismatch: ${formatBackendFederationIdentityIssues(issues)}.`);
+        }
+        return loaded;
+    });
 }
 export { loadBackendFederatedEffectApi };

package/dist/esm-node/runtime/effect/backend-federation/plugin.mjs

@@ -2,13 +2,23 @@ import "node:module";
 function createBackendFederationLoadEntryPlugin(options) {
     return {
         name: 'modernjs-backend-federation-load-entry',
-        async loadEntry ({ remoteInfo }) {
-            return options.resolveEntry({
+        loadEntry ({ remoteInfo }) {
+            return Promise.resolve(options.resolveEntry({
                 name: remoteInfo.name,
                 entry: remoteInfo.entry,
                 type: remoteInfo.type,
                 entryGlobalName: remoteInfo.entryGlobalName,
                 shareScope: remoteInfo.shareScope
+            })).then((entry)=>{
+                if (void 0 === entry) return;
+                return {
+                    get (id) {
+                        return ()=>Promise.resolve(entry.get(id)).then((factory)=>factory());
+                    },
+                    init (...args) {
+                        return entry.init?.(...args);
+                    }
+                };
             });
         }
     };

package/dist/esm-node/runtime/effect/backend-federation/remotes.mjs

@@ -3,10 +3,11 @@ function collectRemotes(options) {
     const remotes = [
         ...options.remotes ?? []
     ];
-    if (options.remote) {
-        const existingIndex = remotes.findIndex((remote)=>remote.name === options.remote?.name);
-        if (existingIndex >= 0) remotes[existingIndex] = options.remote;
-        else remotes.push(options.remote);
+    const configuredRemote = options.remote;
+    if (void 0 !== configuredRemote) {
+        const existingIndex = remotes.findIndex((remote)=>remote.name === configuredRemote.name);
+        if (existingIndex >= 0) remotes[existingIndex] = configuredRemote;
+        else remotes.push(configuredRemote);
     }
     return remotes;
 }

package/dist/esm-node/runtime/effect/backend-federation/runtime.mjs

@@ -1,27 +1,91 @@
 import "node:module";
+import { ModuleFederation } from "@module-federation/runtime";
 import { loadBackendFederationExpose } from "./entry.mjs";
+import { createBackendFederationLoadEntryPlugin } from "./plugin.mjs";
 import { collectRemotes } from "./remotes.mjs";
-import { normalizeExpose } from "./utils.mjs";
-function exposeForRemoteRequest(expose) {
-    return `./${normalizeExpose(expose)}`;
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
 }
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+let nextRuntimeId = 0;
 function parseRemoteRequest(request) {
     const [remoteName, ...exposeParts] = request.split('/');
-    if (!remoteName || 0 === exposeParts.length) throw new Error(`[BFF][Effect] Invalid backend federation request ${request}.`);
-    return {
-        remoteName,
-        expose: exposeForRemoteRequest(exposeParts.join('/'))
-    };
+    if (void 0 === remoteName || 0 === remoteName.length || 0 === exposeParts.length) return;
+    return remoteName;
+}
+function createLocalEntryPlugin(options, remotes) {
+    return createBackendFederationLoadEntryPlugin({
+        resolveEntry (resolvedRemote) {
+            const remote = remotes.find((candidate)=>candidate.name === resolvedRemote.name);
+            if (void 0 === remote) return;
+            return {
+                get (expose) {
+                    return ()=>loadBackendFederationExpose(remote, expose, options);
+                }
+            };
+        }
+    });
+}
+function isolateRegisteredRemoteEntries(remotes) {
+    const runtimeId = nextRuntimeId;
+    nextRuntimeId += 1;
+    return remotes.map((remote)=>({
+            ...remote,
+            entry: `${remote.entry}#modernjs-backend-runtime-${runtimeId}`
+        }));
+}
+var _remoteNames = /*#__PURE__*/ new WeakMap();
+class BackendFederationRuntime extends ModuleFederation {
+    loadRemote(request, loadOptions) {
+        const remoteName = parseRemoteRequest(request);
+        if (void 0 === remoteName) return Promise.reject(new Error(`[BFF][Effect] Invalid backend federation request ${request}.`));
+        if (!_class_private_field_get(this, _remoteNames).has(remoteName)) return Promise.reject(new Error(`[BFF][Effect] Missing backend federation remote ${remoteName}.`));
+        return super.loadRemote(request, loadOptions);
+    }
+    constructor(options, remotes){
+        super({
+            name: options.hostName,
+            remotes: isolateRegisteredRemoteEntries(remotes),
+            shared: {},
+            plugins: [
+                createLocalEntryPlugin(options, remotes)
+            ]
+        }), _class_private_field_init(this, _remoteNames, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _remoteNames, new Set(remotes.map((remote)=>remote.name)));
+    }
 }
 function createBackendFederationRuntime(options) {
     const remotes = 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);
-        }
-    };
+    return new BackendFederationRuntime(options, remotes);
 }
 export { createBackendFederationRuntime };

package/dist/esm-node/runtime/effect/edge-dispatcher.mjs

@@ -0,0 +1,39 @@
+import "node:module";
+import { dispatchEffectBffRequestWithContext } from "./dispatch.mjs";
+import { runWithEffectContext, useEffectContext, useOperationContext } from "./edge-context.mjs";
+import { resolveEffectBffModuleHandler } from "./module.mjs";
+export * from "./handler.mjs";
+async function dispatchEffectBffRequest(handler, request, options = {}) {
+    return dispatchEffectBffRequestWithContext(handler, request, {
+        ...options,
+        runWithEffectContext: runWithEffectContext
+    });
+}
+async function createEffectBffEdgeDispatcher(options) {
+    const loaded = await resolveEffectBffModuleHandler(options.module, {
+        openapi: options.openapi,
+        dataPlatform: options.dataPlatform,
+        onWarning: options.onWarning
+    });
+    if (!loaded) throw new Error('[BFF][Effect] Invalid Effect edge module. Export defineEffectBff(...) or a { api, layer } HttpApi module.');
+    return {
+        dispatch: (request, dispatchOptions = {})=>dispatchEffectBffRequest(loaded.handler, request, {
+                ...dispatchOptions,
+                prefix: options.prefix,
+                onError: options.onError
+            }),
+        dispose: async ()=>{
+            await loaded.dispose?.();
+        }
+    };
+}
+const createEffectBffTestHandler = createEffectBffEdgeHandler;
+async function createEffectBffEdgeHandler(options) {
+    const dispatcher = await createEffectBffEdgeDispatcher(options);
+    return {
+        handler: dispatcher.dispatch,
+        dispose: dispatcher.dispose
+    };
+}
+export { createEffectOperationContext } from "./operation-context.mjs";
+export { createEffectBffEdgeDispatcher, createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest, runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm-node/runtime/effect/edge.mjs

@@ -1,40 +1,3 @@
 import "node:module";
-import { dispatchEffectBffRequestWithContext } from "./dispatch.mjs";
-import { runWithEffectContext, useEffectContext, useOperationContext } from "./edge-context.mjs";
-import { resolveEffectBffModuleHandler } from "./module.mjs";
-export * from "./handler.mjs";
-async function dispatchEffectBffRequest(handler, request, options = {}) {
-    return dispatchEffectBffRequestWithContext(handler, request, {
-        ...options,
-        runWithEffectContext: runWithEffectContext
-    });
-}
-async function createEffectBffEdgeDispatcher(options) {
-    const loaded = await resolveEffectBffModuleHandler(options.module, {
-        openapi: options.openapi,
-        dataPlatform: options.dataPlatform,
-        onWarning: options.onWarning
-    });
-    if (!loaded) throw new Error('[BFF][Effect] Invalid Effect edge module. Export defineEffectBff(...) or a { api, layer } HttpApi module.');
-    return {
-        dispatch: (request, dispatchOptions = {})=>dispatchEffectBffRequest(loaded.handler, request, {
-                ...dispatchOptions,
-                prefix: options.prefix,
-                onError: options.onError
-            }),
-        dispose: async ()=>{
-            await loaded.dispose?.();
-        }
-    };
-}
-const createEffectBffTestHandler = createEffectBffEdgeHandler;
-async function createEffectBffEdgeHandler(options) {
-    const dispatcher = await createEffectBffEdgeDispatcher(options);
-    return {
-        handler: dispatcher.dispatch,
-        dispose: dispatcher.dispose
-    };
-}
+export * from "./edge-dispatcher.mjs";
 export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, loadBackendFederatedEffectApi, validateExpectedBackendFederationIdentity } from "./backend-federation.mjs";
-export { createEffectOperationContext } from "./operation-context.mjs";
-export { createEffectBffEdgeDispatcher, createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest, runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm-node/runtime/effect/handler/definition.mjs

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

package/dist/esm-node/runtime/effect/handler/http.mjs

@@ -13,23 +13,30 @@ function createHttpApiHandler(options) {
     const openApiLayer = createOpenApiLayer(options.api, options.openapi);
     const mergedLayer = openApiLayer ? __rspack_external_effect_Layer_69c46453.mergeAll(apiLayer, openApiLayer) : apiLayer;
     const httpApiHandler = HttpRouter.toWebHandler(mergedLayer);
-    const withDataPlatformValidation = async (request, context)=>{
-        const policyDenial = options.validateRequest?.(request);
-        if (policyDenial) return policyDenial;
+    const dispatchHttpApiRequest = async (request, context)=>{
         const preparedRequest = await prepareJsonRequestBody(request);
         if (preparedRequest instanceof Response) return preparedRequest;
         const validationError = validateDataPlatformRequestEnvelope(preparedRequest, options.dataPlatform);
         if (validationError) return validationError;
         return httpApiHandler.handler(preparedRequest, toEffectServiceContext(context));
     };
+    const withRequestPolicy = async (request, context)=>{
+        const policyDenial = options.validateRequest?.(request);
+        if (policyDenial) return policyDenial;
+        const next = ()=>dispatchHttpApiRequest(request, context);
+        return options.interceptRequest ? options.interceptRequest({
+            request,
+            next
+        }) : next();
+    };
     const batchHandler = createDataPlatformBatchRequestHandler({
         dataPlatform: options.dataPlatform,
-        handleItem: withDataPlatformValidation
+        handleItem: withRequestPolicy
     });
     const handleHttpApiRequest = async (request, context)=>{
         const pathname = getRequestPathname(request);
         if (batchHandler.enabled && pathname === batchHandler.path) return batchHandler.handle(request, context);
-        return withDataPlatformValidation(request, context);
+        return withRequestPolicy(request, context);
     };
     if (!options.rpc) return {
         handler: handleHttpApiRequest,
@@ -44,7 +51,11 @@ function createHttpApiHandler(options) {
             if (isRpcRequest(request, rpcPath)) {
                 const policyDenial = options.validateRequest?.(request);
                 if (policyDenial) return policyDenial;
-                return rpcHandler.handler(request, toEffectServiceContext(context));
+                const next = ()=>rpcHandler.handler(request, toEffectServiceContext(context));
+                return options.interceptRequest ? options.interceptRequest({
+                    request,
+                    next
+                }) : next();
             }
             return handleHttpApiRequest(request, context);
         },

package/dist/esm-node/utils/crossProjectApiPlugin.mjs

@@ -6,6 +6,8 @@ const API_DIR = '{apiDirectory}';
 const LAMBDA_DIR = '{lambdaDirectory}';
 const DIST_DIR = '{distDirectory}';
 const RUNTIME_FRAMEWORK = '{runtimeFramework}';
+const EFFECT_ENTRY = '{effectEntry}';
+const OPERATION_CONTRACTS_JSON = '{operationContracts}';
 const NODE_MODULES = 'node_modules';
 const crossProjectApiPlugin = ()=>({
         name: '@modern-js/plugin-independent-bff',
@@ -17,7 +19,8 @@ const crossProjectApiPlugin = ()=>({
                 const { appDirectory: originAppDirectory } = api.getAppContext();
                 const sdkPath = path.join(originAppDirectory, NODE_MODULES, PACKAGE_NAME);
                 const sdkDistPath = path.join(sdkPath, DIST_DIR);
-                const apiDirectory = path.join(sdkDistPath, API_DIR);
+                const effectEntry = EFFECT_ENTRY ? path.join(sdkDistPath, EFFECT_ENTRY) : void 0;
+                const apiDirectory = effectEntry ? path.dirname(effectEntry) : path.join(sdkDistPath, API_DIR);
                 const lambdaDirectory = path.resolve(sdkDistPath, LAMBDA_DIR);
                 api.updateAppContext({
                     apiDirectory,
@@ -32,10 +35,16 @@ const crossProjectApiPlugin = ()=>({
                 }
                 const configuredRuntimeFramework = config?.bff?.runtimeFramework;
                 if (configuredRuntimeFramework && configuredRuntimeFramework !== RUNTIME_FRAMEWORK) throw new Error(`[${PACKAGE_NAME}] Runtime framework mismatch for cross-project BFF. Detected "${configuredRuntimeFramework}", but producer SDK requires "${RUNTIME_FRAMEWORK}".`);
+                resolvedConfig.bff ??= {};
                 resolvedConfig.bff.prefix = PREFIX;
                 resolvedConfig.bff.runtimeFramework = RUNTIME_FRAMEWORK;
+                if (EFFECT_ENTRY) resolvedConfig.bff.effect = {
+                    ...resolvedConfig.bff.effect,
+                    entry: effectEntry
+                };
                 resolvedConfig.bff.isCrossProjectServer = true;
                 resolvedConfig.bff.requestId = resolvedConfig.bff.requestId || config?.bff?.requestId || PACKAGE_NAME || 'default';
+                const generatedOperationContracts = "{operationContracts}" === OPERATION_CONTRACTS_JSON ? {} : JSON.parse(OPERATION_CONTRACTS_JSON);
                 resolvedConfig.bff.crossProjectPolicy = {
                     ...resolvedConfig.bff.crossProjectPolicy || {},
                     enabled: resolvedConfig.bff.crossProjectPolicy?.enabled ?? true,
@@ -44,7 +53,11 @@ const crossProjectApiPlugin = ()=>({
                     requireOperationContextDetails: resolvedConfig.bff.crossProjectPolicy?.requireOperationContextDetails ?? true,
                     requireOperationSchemaHash: resolvedConfig.bff.crossProjectPolicy?.requireOperationSchemaHash ?? true,
                     requireOperationVersion: resolvedConfig.bff.crossProjectPolicy?.requireOperationVersion ?? true,
-                    allowUnknownOperations: resolvedConfig.bff.crossProjectPolicy?.allowUnknownOperations ?? false
+                    allowUnknownOperations: resolvedConfig.bff.crossProjectPolicy?.allowUnknownOperations ?? false,
+                    expectedOperationContracts: {
+                        ...resolvedConfig.bff.crossProjectPolicy?.expectedOperationContracts || {},
+                        ...generatedOperationContracts
+                    }
                 };
                 return resolvedConfig;
             });
@@ -52,4 +65,4 @@ const crossProjectApiPlugin = ()=>({
     });
 const utils_crossProjectApiPlugin = crossProjectApiPlugin;
 export default utils_crossProjectApiPlugin;
-export { API_DIR, DIST_DIR, LAMBDA_DIR, PACKAGE_NAME, PREFIX, RUNTIME_FRAMEWORK, crossProjectApiPlugin };
+export { API_DIR, DIST_DIR, EFFECT_ENTRY, LAMBDA_DIR, OPERATION_CONTRACTS_JSON, PACKAGE_NAME, PREFIX, RUNTIME_FRAMEWORK, crossProjectApiPlugin };

package/dist/esm-node/utils/effect-client-generator/generator.mjs

@@ -3,26 +3,27 @@ import { logger } from "@modern-js/utils";
 import { collectEffectEndpoints } from "../../runtime/effect/endpoint-contracts.mjs";
 import { renderEffectClientCode, renderEffectClientDeclaration } from "./rendering.mjs";
 import { getHttpApiRuntime, loadEffectApi } from "./runtime.mjs";
-async function generateEffectClient(options) {
-    const api = await loadEffectApi({
+function generateEffectClient(options) {
+    return loadEffectApi({
         appDir: options.appDir,
         resourcePath: options.resourcePath,
         onDependency: options.onDependency
+    }).then((api)=>{
+        if (null === api) {
+            logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
+            return null;
+        }
+        return getHttpApiRuntime().then((httpApiRuntime)=>{
+            const endpoints = collectEffectEndpoints(httpApiRuntime.reflect, api, options.prefix);
+            return {
+                code: renderEffectClientCode(endpoints, options),
+                declaration: renderEffectClientDeclaration(endpoints),
+                endpoints
+            };
+        });
     });
-    if (!api) {
-        logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
-        return null;
-    }
-    const httpApiRuntime = await getHttpApiRuntime();
-    const endpoints = collectEffectEndpoints(httpApiRuntime.reflect, api, options.prefix);
-    return {
-        code: renderEffectClientCode(endpoints, options),
-        declaration: renderEffectClientDeclaration(endpoints),
-        endpoints
-    };
 }
-async function generateEffectClientCode(options) {
-    const artifacts = await generateEffectClient(options);
-    return artifacts ? artifacts.code : null;
+function generateEffectClientCode(options) {
+    return generateEffectClient(options).then((artifacts)=>null === artifacts ? null : artifacts.code);
 }
 export { generateEffectClient, generateEffectClientCode };

package/dist/esm-node/utils/effect-client-generator/paths.mjs

@@ -1,6 +1,5 @@
 import "node:module";
-import { findExists, fs } from "@modern-js/utils";
-import path from "path";
+import { findExists, fs, upath } from "@modern-js/utils";
 const JS_OR_TS_EXTS = [
     '.js',
     '.jsx',
@@ -14,13 +13,13 @@ const JS_OR_TS_EXTS = [
 function resolveEffectEntryFile(options) {
     const { appDir, apiDir, effectEntry } = options;
     const resolveEntry = (entryWithoutExt)=>{
-        if (path.extname(entryWithoutExt)) return fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
+        if ('' !== upath.extname(entryWithoutExt)) return fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
         return findExists(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutExt}${ext}`));
     };
-    if (effectEntry) {
-        const entryWithoutExt = path.isAbsolute(effectEntry) ? effectEntry : path.resolve(appDir, effectEntry);
+    if (void 0 !== effectEntry && '' !== effectEntry) {
+        const entryWithoutExt = upath.isAbsolute(effectEntry) ? effectEntry : upath.resolve(appDir, effectEntry);
         return resolveEntry(entryWithoutExt);
     }
-    return resolveEntry(path.resolve(apiDir, 'index'));
+    return resolveEntry(upath.resolve(apiDir, 'index'));
 }
 export { resolveEffectEntryFile };

package/dist/esm-node/utils/effect-client-generator/rendering.mjs

@@ -1,7 +1,6 @@
 import "node:module";
 import { deriveOperationVersion } from "@modern-js/bff-core";
-import { fs } from "@modern-js/utils";
-import path from "path";
+import { fs, upath } from "@modern-js/utils";
 import { createEffectEndpointContractHash, ensureLeadingSlash, normalizeEffectPrefix } from "../../runtime/effect/endpoint-contracts.mjs";
 const DEFAULT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
 const EFFECT_CLIENT_RUNTIME_IMPORT = '@modern-js/plugin-bff/effect-client-runtime';
@@ -14,17 +13,17 @@ function isAbsoluteUrl(value) {
     }
 }
 function resolveBatchEndpoint(prefix, endpoint) {
-    const value = endpoint || '/_data/batch';
+    const value = void 0 === endpoint || '' === endpoint ? '/_data/batch' : endpoint;
     if (isAbsoluteUrl(value)) return value;
     const normalizedPrefix = normalizeEffectPrefix(prefix);
     const normalizedEndpoint = ensureLeadingSlash(value);
-    if (!normalizedPrefix) return normalizedEndpoint;
+    if ('' === normalizedPrefix) return normalizedEndpoint;
     if (normalizedEndpoint === normalizedPrefix || normalizedEndpoint.startsWith(`${normalizedPrefix}/`)) return normalizedEndpoint;
     return `${normalizedPrefix}${'/' === normalizedEndpoint ? '' : normalizedEndpoint}`;
 }
 function getPackageInfo(appDir) {
     try {
-        const packageJsonPath = path.resolve(appDir, './package.json');
+        const packageJsonPath = upath.resolve(appDir, './package.json');
         const packageJson = fs.readJSONSync(packageJsonPath);
         return {
             name: packageJson.name,
@@ -39,9 +38,9 @@ function renderEffectClientCode(endpoints, options) {
     const httpMethodDecider = options.httpMethodDecider || 'functionName';
     const packageInfo = getPackageInfo(options.appDir);
     const packageName = packageInfo.name;
-    const dataPlatformAppNamespace = packageName || 'unknown-app';
-    const requestId = 'bundle' === options.target ? packageName || process.env.npm_package_name : void 0;
-    const normalizedRequestId = requestId || 'default';
+    const dataPlatformAppNamespace = void 0 === packageName || '' === packageName ? 'unknown-app' : packageName;
+    const requestId = 'bundle' === options.target ? void 0 !== packageName && '' !== packageName ? packageName : void 0 : void 0;
+    const normalizedRequestId = void 0 === requestId || '' === requestId ? 'default' : requestId;
     const operationVersion = deriveOperationVersion(packageInfo.version);
     const batchConfig = options.dataPlatformBatch;
     const batchEndpoint = resolveBatchEndpoint(options.prefix, batchConfig?.endpoint);
@@ -58,7 +57,7 @@ function renderEffectClientCode(endpoints, options) {
     };
     const config = {
         appNamespace: dataPlatformAppNamespace,
-        ...requestId ? {
+        ...void 0 !== requestId && '' !== requestId ? {
             requestId
         } : {},
         port: options.port,
@@ -72,7 +71,7 @@ function renderEffectClientCode(endpoints, options) {
             maxBatchSize: batchConfig?.maxBatchSize ?? 16,
             maxBatchBytes: batchConfig?.maxBatchBytes ?? 65536,
             requestTimeoutMs: batchConfig?.requestTimeoutMs ?? 10000,
-            allowedMethods: batchConfig?.allowedMethods && batchConfig.allowedMethods.length > 0 ? batchConfig.allowedMethods : [
+            allowedMethods: batchConfig?.allowedMethods !== void 0 && batchConfig.allowedMethods.length > 0 ? batchConfig.allowedMethods : [
                 'GET'
             ]
         }

package/dist/esm-node/utils/effect-client-generator/runtime.mjs

@@ -1,36 +1,29 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import { compatibleRequire } from "@modern-js/utils";
-import path from "path";
+import { compatibleRequire, upath } from "@modern-js/utils";
 import { extractHttpApiFromModule } from "../../runtime/effect/endpoint-contracts.mjs";
 import { loadEffectSourceModule } from "../effectSourceLoader.mjs";
 let httpApiRuntimePromise;
 function isRecord(value) {
     return 'object' == typeof value && null !== value;
 }
-async function getHttpApiRuntime() {
-    if (!httpApiRuntimePromise) httpApiRuntimePromise = (async ()=>{
-        let mod;
-        try {
-            mod = await compatibleRequire('effect/unstable/httpapi', false);
-        } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (!message.includes("Cannot find module 'effect/unstable/httpapi'")) throw error;
-            const effectPackageJson = require.resolve('effect/package.json');
-            const effectHttpApiRuntimePath = path.join(path.dirname(effectPackageJson), 'dist', 'unstable', 'httpapi', 'index.js');
-            mod = await compatibleRequire(effectHttpApiRuntimePath, false);
-        }
-        if (isRecord(mod) && isRecord(mod.HttpApi)) {
-            const maybeHttpApi = mod.HttpApi;
-            if ('function' == typeof maybeHttpApi.isHttpApi && 'function' == typeof maybeHttpApi.reflect) return maybeHttpApi;
-        }
+function isHttpApiRuntime(value) {
+    return isRecord(value) && 'function' == typeof value.isHttpApi && 'function' == typeof value.reflect;
+}
+function getHttpApiRuntime() {
+    if (void 0 === httpApiRuntimePromise) httpApiRuntimePromise = compatibleRequire('effect/unstable/httpapi', false).catch((error)=>{
+        const message = error instanceof Error ? error.message : String(error);
+        if (!message.includes("Cannot find module 'effect/unstable/httpapi'")) throw error;
+        const effectPackageJson = require.resolve('effect/package.json');
+        const effectHttpApiRuntimePath = upath.join(upath.dirname(effectPackageJson), 'dist', 'unstable', 'httpapi', 'index.js');
+        return compatibleRequire(effectHttpApiRuntimePath, false);
+    }).then((mod)=>{
+        if (isRecord(mod) && isHttpApiRuntime(mod.HttpApi)) return mod.HttpApi;
         throw new Error('[BFF][Effect] Unable to resolve HttpApi runtime from effect/unstable/httpapi.');
-    })();
+    });
     return httpApiRuntimePromise;
 }
-async function loadEffectApi(options) {
-    const httpApiRuntime = await getHttpApiRuntime();
-    const mod = await loadEffectSourceModule(options);
-    return extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi);
+function loadEffectApi(options) {
+    return getHttpApiRuntime().then((httpApiRuntime)=>loadEffectSourceModule(options).then((mod)=>extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi)));
 }
 export { getHttpApiRuntime, loadEffectApi };