@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.102 → 3.5.0-ultramodern.103

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

@@ -30,30 +30,94 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createBackendFederationRuntime: ()=>createBackendFederationRuntime
 });
+const runtime_namespaceObject = require("@module-federation/runtime");
 const external_entry_js_namespaceObject = require("./entry.js");
+const external_plugin_js_namespaceObject = require("./plugin.js");
 const external_remotes_js_namespaceObject = require("./remotes.js");
-const external_utils_js_namespaceObject = require("./utils.js");
-function exposeForRemoteRequest(expose) {
-    return `./${(0, external_utils_js_namespaceObject.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 (0, external_plugin_js_namespaceObject.createBackendFederationLoadEntryPlugin)({
+        resolveEntry (resolvedRemote) {
+            const remote = remotes.find((candidate)=>candidate.name === resolvedRemote.name);
+            if (void 0 === remote) return;
+            return {
+                get (expose) {
+                    return ()=>(0, external_entry_js_namespaceObject.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 runtime_namespaceObject.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 = (0, external_remotes_js_namespaceObject.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 (0, external_entry_js_namespaceObject.loadBackendFederationExpose)(remote, expose, options);
-        }
-    };
+    return new BackendFederationRuntime(options, remotes);
 }
 exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

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

@@ -0,0 +1,148 @@
+"use strict";
+var __webpack_modules__ = {
+    "./dispatch" (module) {
+        module.exports = require("./dispatch.js");
+    },
+    "./edge-context" (module) {
+        module.exports = require("./edge-context.js");
+    },
+    "./handler" (module) {
+        module.exports = require("./handler.js");
+    },
+    "./module" (module) {
+        module.exports = require("./module.js");
+    },
+    "./operation-context" (module) {
+        module.exports = require("./operation-context.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _dispatch__rspack_import_0 = __webpack_require__("./dispatch");
+    var _edge_context__rspack_import_1 = __webpack_require__("./edge-context");
+    var _module__rspack_import_2 = __webpack_require__("./module");
+    var _handler__rspack_import_3 = __webpack_require__("./handler");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _handler__rspack_import_3)if ([
+        "runWithEffectContext",
+        "useEffectContext",
+        "default",
+        "useOperationContext",
+        "createEffectOperationContext",
+        "dispatchEffectBffRequest",
+        "createEffectBffTestHandler",
+        "createEffectBffEdgeHandler",
+        "createEffectBffEdgeDispatcher"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _operation_context__rspack_import_4 = __webpack_require__("./operation-context");
+    async function dispatchEffectBffRequest(handler, request, options = {}) {
+        return (0, _dispatch__rspack_import_0.dispatchEffectBffRequestWithContext)(handler, request, {
+            ...options,
+            runWithEffectContext: _edge_context__rspack_import_1.runWithEffectContext
+        });
+    }
+    async function createEffectBffEdgeDispatcher(options) {
+        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 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
+        };
+    }
+    __webpack_require__.d(__webpack_exports__, {
+        createEffectBffEdgeDispatcher: ()=>createEffectBffEdgeDispatcher,
+        createEffectBffEdgeHandler: ()=>createEffectBffEdgeHandler,
+        createEffectOperationContext: ()=>_operation_context__rspack_import_4.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.createEffectBffEdgeDispatcher = __webpack_exports__.createEffectBffEdgeDispatcher;
+exports.createEffectBffEdgeHandler = __webpack_exports__.createEffectBffEdgeHandler;
+exports.createEffectBffTestHandler = __webpack_exports__.createEffectBffTestHandler;
+exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
+exports.dispatchEffectBffRequest = __webpack_exports__.dispatchEffectBffRequest;
+exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
+exports.useEffectContext = __webpack_exports__.useEffectContext;
+exports.useOperationContext = __webpack_exports__.useOperationContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEffectBffEdgeDispatcher",
+    "createEffectBffEdgeHandler",
+    "createEffectBffTestHandler",
+    "createEffectOperationContext",
+    "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/edge.js

@@ -3,20 +3,8 @@ var __webpack_modules__ = {
     "./backend-federation" (module) {
         module.exports = require("./backend-federation.js");
     },
-    "./dispatch" (module) {
-        module.exports = require("./dispatch.js");
-    },
-    "./edge-context" (module) {
-        module.exports = require("./edge-context.js");
-    },
-    "./handler" (module) {
-        module.exports = require("./handler.js");
-    },
-    "./module" (module) {
-        module.exports = require("./module.js");
-    },
-    "./operation-context" (module) {
-        module.exports = require("./operation-context.js");
+    "./edge-dispatcher" (module) {
+        module.exports = require("./edge-dispatcher.js");
     }
 };
 var __webpack_module_cache__ = {};
@@ -66,83 +54,30 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var _dispatch__rspack_import_0 = __webpack_require__("./dispatch");
-    var _edge_context__rspack_import_1 = __webpack_require__("./edge-context");
-    var _module__rspack_import_2 = __webpack_require__("./module");
-    var _backend_federation__rspack_import_3 = __webpack_require__("./backend-federation");
-    var _handler__rspack_import_4 = __webpack_require__("./handler");
+    var _backend_federation__rspack_import_0 = __webpack_require__("./backend-federation");
+    var _edge_dispatcher__rspack_import_1 = __webpack_require__("./edge-dispatcher");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _handler__rspack_import_4)if ([
+    for(const __rspack_import_key in _edge_dispatcher__rspack_import_1)if ([
         "validateExpectedBackendFederationIdentity",
-        "createBackendFederationLoadEntryPlugin",
-        "useOperationContext",
-        "BACKEND_FEDERATION_MANIFEST_FILE",
-        "createEffectOperationContext",
-        "loadBackendFederatedEffectApi",
-        "BACKEND_FEDERATION_CONTRACT_VERSION",
-        "createEffectBffEdgeHandler",
-        "runWithEffectContext",
         "BACKEND_FEDERATION_EFFECT_EXPOSE",
-        "useEffectContext",
-        "dispatchEffectBffRequest",
         "default",
+        "createBackendFederationLoadEntryPlugin",
+        "BACKEND_FEDERATION_MANIFEST_FILE",
         "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
-        "createEffectBffTestHandler",
-        "createBackendFederationRuntime",
-        "createEffectBffEdgeDispatcher"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_4[__rspack_import_key];
+        "BACKEND_FEDERATION_CONTRACT_VERSION",
+        "loadBackendFederatedEffectApi",
+        "createBackendFederationRuntime"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_edge_dispatcher__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _operation_context__rspack_import_5 = __webpack_require__("./operation-context");
-    async function dispatchEffectBffRequest(handler, request, options = {}) {
-        return (0, _dispatch__rspack_import_0.dispatchEffectBffRequestWithContext)(handler, request, {
-            ...options,
-            runWithEffectContext: _edge_context__rspack_import_1.runWithEffectContext
-        });
-    }
-    async function createEffectBffEdgeDispatcher(options) {
-        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 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
-        };
-    }
     __webpack_require__.d(__webpack_exports__, {
-        BACKEND_FEDERATION_CONTRACT_VERSION: ()=>_backend_federation__rspack_import_3.BACKEND_FEDERATION_CONTRACT_VERSION,
-        BACKEND_FEDERATION_EFFECT_EXPOSE: ()=>_backend_federation__rspack_import_3.BACKEND_FEDERATION_EFFECT_EXPOSE,
-        BACKEND_FEDERATION_MANIFEST_FILE: ()=>_backend_federation__rspack_import_3.BACKEND_FEDERATION_MANIFEST_FILE,
-        BACKEND_FEDERATION_NODE_ADAPTER_VERSION: ()=>_backend_federation__rspack_import_3.BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
-        createBackendFederationLoadEntryPlugin: ()=>_backend_federation__rspack_import_3.createBackendFederationLoadEntryPlugin,
-        createBackendFederationRuntime: ()=>_backend_federation__rspack_import_3.createBackendFederationRuntime,
-        createEffectBffEdgeDispatcher: ()=>createEffectBffEdgeDispatcher,
-        createEffectBffEdgeHandler: ()=>createEffectBffEdgeHandler,
-        createEffectOperationContext: ()=>_operation_context__rspack_import_5.createEffectOperationContext,
-        dispatchEffectBffRequest: ()=>dispatchEffectBffRequest,
-        loadBackendFederatedEffectApi: ()=>_backend_federation__rspack_import_3.loadBackendFederatedEffectApi,
-        runWithEffectContext: ()=>_edge_context__rspack_import_1.runWithEffectContext,
-        useEffectContext: ()=>_edge_context__rspack_import_1.useEffectContext,
-        useOperationContext: ()=>_edge_context__rspack_import_1.useOperationContext,
-        validateExpectedBackendFederationIdentity: ()=>_backend_federation__rspack_import_3.validateExpectedBackendFederationIdentity
-    }, {
-        createEffectBffTestHandler: createEffectBffTestHandler
+        BACKEND_FEDERATION_CONTRACT_VERSION: ()=>_backend_federation__rspack_import_0.BACKEND_FEDERATION_CONTRACT_VERSION,
+        BACKEND_FEDERATION_EFFECT_EXPOSE: ()=>_backend_federation__rspack_import_0.BACKEND_FEDERATION_EFFECT_EXPOSE,
+        BACKEND_FEDERATION_MANIFEST_FILE: ()=>_backend_federation__rspack_import_0.BACKEND_FEDERATION_MANIFEST_FILE,
+        BACKEND_FEDERATION_NODE_ADAPTER_VERSION: ()=>_backend_federation__rspack_import_0.BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+        createBackendFederationLoadEntryPlugin: ()=>_backend_federation__rspack_import_0.createBackendFederationLoadEntryPlugin,
+        createBackendFederationRuntime: ()=>_backend_federation__rspack_import_0.createBackendFederationRuntime,
+        loadBackendFederatedEffectApi: ()=>_backend_federation__rspack_import_0.loadBackendFederatedEffectApi,
+        validateExpectedBackendFederationIdentity: ()=>_backend_federation__rspack_import_0.validateExpectedBackendFederationIdentity
     });
 })();
 exports.BACKEND_FEDERATION_CONTRACT_VERSION = __webpack_exports__.BACKEND_FEDERATION_CONTRACT_VERSION;
@@ -151,15 +86,7 @@ exports.BACKEND_FEDERATION_MANIFEST_FILE = __webpack_exports__.BACKEND_FEDERATIO
 exports.BACKEND_FEDERATION_NODE_ADAPTER_VERSION = __webpack_exports__.BACKEND_FEDERATION_NODE_ADAPTER_VERSION;
 exports.createBackendFederationLoadEntryPlugin = __webpack_exports__.createBackendFederationLoadEntryPlugin;
 exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
-exports.createEffectBffEdgeDispatcher = __webpack_exports__.createEffectBffEdgeDispatcher;
-exports.createEffectBffEdgeHandler = __webpack_exports__.createEffectBffEdgeHandler;
-exports.createEffectBffTestHandler = __webpack_exports__.createEffectBffTestHandler;
-exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
-exports.dispatchEffectBffRequest = __webpack_exports__.dispatchEffectBffRequest;
 exports.loadBackendFederatedEffectApi = __webpack_exports__.loadBackendFederatedEffectApi;
-exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
-exports.useEffectContext = __webpack_exports__.useEffectContext;
-exports.useOperationContext = __webpack_exports__.useOperationContext;
 exports.validateExpectedBackendFederationIdentity = __webpack_exports__.validateExpectedBackendFederationIdentity;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "BACKEND_FEDERATION_CONTRACT_VERSION",
@@ -168,15 +95,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
     "createBackendFederationLoadEntryPlugin",
     "createBackendFederationRuntime",
-    "createEffectBffEdgeDispatcher",
-    "createEffectBffEdgeHandler",
-    "createEffectBffTestHandler",
-    "createEffectOperationContext",
-    "dispatchEffectBffRequest",
     "loadBackendFederatedEffectApi",
-    "runWithEffectContext",
-    "useEffectContext",
-    "useOperationContext",
     "validateExpectedBackendFederationIdentity"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/utils/effect-client-generator/generator.js

@@ -35,27 +35,28 @@ const utils_namespaceObject = require("@modern-js/utils");
 const endpoint_contracts_js_namespaceObject = require("../../runtime/effect/endpoint-contracts.js");
 const external_rendering_js_namespaceObject = require("./rendering.js");
 const external_runtime_js_namespaceObject = require("./runtime.js");
-async function generateEffectClient(options) {
-    const api = await (0, external_runtime_js_namespaceObject.loadEffectApi)({
+function generateEffectClient(options) {
+    return (0, external_runtime_js_namespaceObject.loadEffectApi)({
         appDir: options.appDir,
         resourcePath: options.resourcePath,
         onDependency: options.onDependency
+    }).then((api)=>{
+        if (null === api) {
+            utils_namespaceObject.logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
+            return null;
+        }
+        return (0, external_runtime_js_namespaceObject.getHttpApiRuntime)().then((httpApiRuntime)=>{
+            const endpoints = (0, endpoint_contracts_js_namespaceObject.collectEffectEndpoints)(httpApiRuntime.reflect, api, options.prefix);
+            return {
+                code: (0, external_rendering_js_namespaceObject.renderEffectClientCode)(endpoints, options),
+                declaration: (0, external_rendering_js_namespaceObject.renderEffectClientDeclaration)(endpoints),
+                endpoints
+            };
+        });
     });
-    if (!api) {
-        utils_namespaceObject.logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
-        return null;
-    }
-    const httpApiRuntime = await (0, external_runtime_js_namespaceObject.getHttpApiRuntime)();
-    const endpoints = (0, endpoint_contracts_js_namespaceObject.collectEffectEndpoints)(httpApiRuntime.reflect, api, options.prefix);
-    return {
-        code: (0, external_rendering_js_namespaceObject.renderEffectClientCode)(endpoints, options),
-        declaration: (0, external_rendering_js_namespaceObject.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);
 }
 exports.generateEffectClient = __webpack_exports__.generateEffectClient;
 exports.generateEffectClientCode = __webpack_exports__.generateEffectClientCode;

package/dist/cjs/utils/effect-client-generator/paths.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)=>{
@@ -40,8 +31,6 @@ __webpack_require__.d(__webpack_exports__, {
     resolveEffectEntryFile: ()=>resolveEffectEntryFile
 });
 const utils_namespaceObject = require("@modern-js/utils");
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const JS_OR_TS_EXTS = [
     '.js',
     '.jsx',
@@ -55,14 +44,14 @@ const JS_OR_TS_EXTS = [
 function resolveEffectEntryFile(options) {
     const { appDir, apiDir, effectEntry } = options;
     const resolveEntry = (entryWithoutExt)=>{
-        if (external_path_default().extname(entryWithoutExt)) return utils_namespaceObject.fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
+        if ('' !== utils_namespaceObject.upath.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);
+    if (void 0 !== effectEntry && '' !== effectEntry) {
+        const entryWithoutExt = utils_namespaceObject.upath.isAbsolute(effectEntry) ? effectEntry : utils_namespaceObject.upath.resolve(appDir, effectEntry);
         return resolveEntry(entryWithoutExt);
     }
-    return resolveEntry(external_path_default().resolve(apiDir, 'index'));
+    return resolveEntry(utils_namespaceObject.upath.resolve(apiDir, 'index'));
 }
 exports.resolveEffectEntryFile = __webpack_exports__.resolveEffectEntryFile;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/utils/effect-client-generator/rendering.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)=>{
@@ -42,8 +33,6 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const bff_core_namespaceObject = require("@modern-js/bff-core");
 const utils_namespaceObject = require("@modern-js/utils");
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const endpoint_contracts_js_namespaceObject = require("../../runtime/effect/endpoint-contracts.js");
 const DEFAULT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
 const EFFECT_CLIENT_RUNTIME_IMPORT = '@modern-js/plugin-bff/effect-client-runtime';
@@ -56,17 +45,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 = (0, endpoint_contracts_js_namespaceObject.normalizeEffectPrefix)(prefix);
     const normalizedEndpoint = (0, endpoint_contracts_js_namespaceObject.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 = external_path_default().resolve(appDir, './package.json');
+        const packageJsonPath = utils_namespaceObject.upath.resolve(appDir, './package.json');
         const packageJson = utils_namespaceObject.fs.readJSONSync(packageJsonPath);
         return {
             name: packageJson.name,
@@ -81,9 +70,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 = (0, bff_core_namespaceObject.deriveOperationVersion)(packageInfo.version);
     const batchConfig = options.dataPlatformBatch;
     const batchEndpoint = resolveBatchEndpoint(options.prefix, batchConfig?.endpoint);
@@ -100,7 +89,7 @@ function renderEffectClientCode(endpoints, options) {
     };
     const config = {
         appNamespace: dataPlatformAppNamespace,
-        ...requestId ? {
+        ...void 0 !== requestId && '' !== requestId ? {
             requestId
         } : {},
         port: options.port,
@@ -114,7 +103,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/cjs/utils/effect-client-generator/runtime.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)=>{
@@ -41,38 +32,30 @@ __webpack_require__.d(__webpack_exports__, {
     loadEffectApi: ()=>loadEffectApi
 });
 const utils_namespaceObject = require("@modern-js/utils");
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const endpoint_contracts_js_namespaceObject = require("../../runtime/effect/endpoint-contracts.js");
 const external_effectSourceLoader_js_namespaceObject = require("../effectSourceLoader.js");
 let httpApiRuntimePromise;
 function isRecord(value) {
     return 'object' == typeof value && null !== value;
 }
-async function getHttpApiRuntime() {
-    if (!httpApiRuntimePromise) httpApiRuntimePromise = (async ()=>{
-        let mod;
-        try {
-            mod = await (0, utils_namespaceObject.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 = external_path_default().join(external_path_default().dirname(effectPackageJson), 'dist', 'unstable', 'httpapi', 'index.js');
-            mod = await (0, utils_namespaceObject.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 = (0, utils_namespaceObject.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 = utils_namespaceObject.upath.join(utils_namespaceObject.upath.dirname(effectPackageJson), 'dist', 'unstable', 'httpapi', 'index.js');
+        return (0, utils_namespaceObject.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 (0, external_effectSourceLoader_js_namespaceObject.loadEffectSourceModule)(options);
-    return (0, endpoint_contracts_js_namespaceObject.extractHttpApiFromModule)(mod, httpApiRuntime.isHttpApi);
+function loadEffectApi(options) {
+    return getHttpApiRuntime().then((httpApiRuntime)=>(0, external_effectSourceLoader_js_namespaceObject.loadEffectSourceModule)(options).then((mod)=>(0, endpoint_contracts_js_namespaceObject.extractHttpApiFromModule)(mod, httpApiRuntime.isHttpApi)));
 }
 exports.getHttpApiRuntime = __webpack_exports__.getHttpApiRuntime;
 exports.loadEffectApi = __webpack_exports__.loadEffectApi;