@bleedingdev/modern-js-plugin-bff-extensions 3.8.3-ultramodern.2

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

@@ -0,0 +1,187 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    EffectAdapter: ()=>EffectAdapter
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const effect_namespaceObject = require("@modern-js/bff-effect/effect");
+const runtime_lifecycle_namespaceObject = require("@modern-js/server-runtime-extensions/runtime-lifecycle");
+const utils_namespaceObject = require("@modern-js/utils");
+const evaluation_js_namespaceObject = require("../cross-project-policy/evaluation.js");
+const loader_js_namespaceObject = require("../effect-source-loader/loader.js");
+const external_cross_project_policy_js_namespaceObject = require("./cross-project-policy.js");
+const external_entry_js_namespaceObject = require("./entry.js");
+const external_error_response_js_namespaceObject = require("./error-response.js");
+const EFFECT_MIDDLEWARE_BEFORE = [
+    'custom-server-hook',
+    'custom-server-middleware',
+    'render'
+];
+class EffectAdapter {
+    async loadHandler() {
+        const entryFile = (0, external_entry_js_namespaceObject.resolveEffectAdapterEntryFile)(this.api);
+        if (!entryFile || !await utils_namespaceObject.fs.pathExists(entryFile)) {
+            this.handler = null;
+            return;
+        }
+        let mod;
+        try {
+            const { appDirectory } = this.api.getServerContext();
+            mod = await ((0, utils_namespaceObject.isProd)() ? (0, loader_js_namespaceObject.loadEffectBuiltModule)(entryFile) : (0, loader_js_namespaceObject.loadEffectSourceModule)({
+                resourcePath: entryFile,
+                appDir: appDirectory || external_node_path_default().dirname(entryFile)
+            }));
+        } catch (error) {
+            utils_namespaceObject.logger.error(`[BFF][Effect] Failed to load Effect entry: ${entryFile}\n${String(error)}`);
+            throw error;
+        }
+        const crossProjectPolicies = new Map(await Promise.all(this.prefixes.map(async (prefix)=>[
+                prefix,
+                await (0, external_cross_project_policy_js_namespaceObject.resolveEffectAdapterCrossProjectPolicy)(this.api, prefix, mod)
+            ])));
+        const effectConfig = this.api.getServerConfig()?.bff?.effect;
+        const loaded = await (0, effect_namespaceObject.resolveEffectBffModuleHandler)(mod, {
+            openapi: effectConfig?.openapi,
+            dataPlatform: effectConfig?.dataPlatform,
+            validateRequest: (request)=>{
+                const { path: mountedPathname } = (0, effect_namespaceObject.useEffectContext)();
+                const prefix = this.matchingPrefixes.find((item)=>'/' === item || mountedPathname === item || mountedPathname.startsWith(`${item}/`));
+                if (!prefix) return null;
+                const requestUrl = new URL(request.url);
+                if ('/' !== prefix) requestUrl.pathname = '/' === requestUrl.pathname ? prefix : `${prefix}${requestUrl.pathname}`;
+                return (0, evaluation_js_namespaceObject.checkCrossProjectPolicyForRequest)(new Request(requestUrl, request), crossProjectPolicies.get(prefix));
+            },
+            onWarning: (message)=>utils_namespaceObject.logger.warn(message)
+        });
+        if (!loaded) {
+            const error = new Error(`[BFF][Effect] Invalid Effect entry module: ${entryFile}. Export defineEffectBff(...) or a { api, layer } HttpApi module.`);
+            utils_namespaceObject.logger.warn(error.message);
+            throw error;
+        }
+        const candidateOwner = {};
+        if (loaded.dispose) (0, runtime_lifecycle_namespaceObject.registerServerRuntimeDisposer)(candidateOwner, loaded.dispose);
+        const candidate = (0, runtime_lifecycle_namespaceObject.createDisposableServerRuntimeHandle)(candidateOwner, loaded.handler);
+        if (this.retired) {
+            await candidate.dispose();
+            throw new Error('Cannot initialize a retired Effect adapter.');
+        }
+        this.handler = candidate;
+    }
+    constructor(api){
+        this.handler = null;
+        this.prefix = '/api';
+        this.prefixes = [
+            '/api'
+        ];
+        this.matchingPrefixes = [
+            '/api'
+        ];
+        this.retired = false;
+        this.registerMiddleware = async (options)=>{
+            const { enableHandleWeb } = options;
+            const { bffRuntimeFramework, middlewares: globalMiddlewares } = this.api.getServerContext();
+            if ('hono' === bffRuntimeFramework) return;
+            const configuredPrefixes = Array.isArray(options.prefix) ? options.prefix.filter(Boolean) : [
+                options.prefix || '/api'
+            ];
+            this.prefixes = [
+                ...new Set(configuredPrefixes.length > 0 ? configuredPrefixes : [
+                    '/api'
+                ])
+            ];
+            this.matchingPrefixes = [
+                ...this.prefixes
+            ].sort((left, right)=>right.length - left.length);
+            this.prefix = this.prefixes[0] || '/api';
+            const { serverBase } = this.api.getServerContext();
+            if (serverBase) this.unregisterRuntimeDisposer = (0, runtime_lifecycle_namespaceObject.registerServerRuntimeDisposer)(serverBase, this.dispose);
+            try {
+                await this.loadHandler();
+            } catch (error) {
+                await this.dispose();
+                throw error;
+            }
+            const middlewarePrefixes = enableHandleWeb ? [
+                this.prefix
+            ] : this.matchingPrefixes;
+            const middlewares = middlewarePrefixes.map((middlewarePrefix)=>({
+                    name: 'effect-api-handler',
+                    path: enableHandleWeb ? '*' : `${middlewarePrefix}/*`,
+                    method: 'all',
+                    order: 'post',
+                    before: EFFECT_MIDDLEWARE_BEFORE,
+                    handler: async (context, next)=>{
+                        const handler = this.handler;
+                        if (!handler) {
+                            if (enableHandleWeb) return void await next();
+                            return (0, external_error_response_js_namespaceObject.createEffectAdapterRuntimeErrorResponse)(this.api, new Error('[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.'), context);
+                        }
+                        const prefix = enableHandleWeb ? this.matchingPrefixes.find((item)=>'/' === item || context.req.path === item || context.req.path.startsWith(`${item}/`)) || this.prefix : middlewarePrefix;
+                        const response = await (0, effect_namespaceObject.dispatchEffectBffRequest)(handler, context.req.raw, {
+                            prefix,
+                            env: context.env,
+                            path: context.req.path,
+                            method: context.req.method,
+                            onError: (error)=>(0, external_error_response_js_namespaceObject.createEffectAdapterRuntimeErrorResponse)(this.api, error, context)
+                        });
+                        if (404 === response.status && enableHandleWeb) return void await next();
+                        return new Response(response.body, response);
+                    }
+                }));
+            globalMiddlewares.push(...middlewares);
+        };
+        this.dispose = async ()=>{
+            this.retired = true;
+            this.unregisterRuntimeDisposer?.();
+            this.unregisterRuntimeDisposer = void 0;
+            const previous = this.handler;
+            this.handler = null;
+            await previous?.dispose();
+        };
+        this.api = api;
+    }
+}
+exports.EffectAdapter = __webpack_exports__.EffectAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EffectAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,51 @@
+"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__, {
+    bundleEffectEntryForNode: ()=>external_loader_js_namespaceObject.bundleEffectEntryForNode,
+    generateEffectClientCode: ()=>external_worker_runtime_wrapper_js_namespaceObject.generateEffectClientCode,
+    generateEffectWorkerRuntimeWrapper: ()=>external_worker_runtime_wrapper_js_namespaceObject.generateEffectWorkerRuntimeWrapper,
+    resolveEffectEntryFile: ()=>paths_js_namespaceObject.resolveEffectEntryFile
+});
+const paths_js_namespaceObject = require("../client-generator/paths.js");
+const external_loader_js_namespaceObject = require("./loader.js");
+const external_worker_runtime_wrapper_js_namespaceObject = require("./worker-runtime-wrapper.js");
+exports.bundleEffectEntryForNode = __webpack_exports__.bundleEffectEntryForNode;
+exports.generateEffectClientCode = __webpack_exports__.generateEffectClientCode;
+exports.generateEffectWorkerRuntimeWrapper = __webpack_exports__.generateEffectWorkerRuntimeWrapper;
+exports.resolveEffectEntryFile = __webpack_exports__.resolveEffectEntryFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "bundleEffectEntryForNode",
+    "generateEffectClientCode",
+    "generateEffectWorkerRuntimeWrapper",
+    "resolveEffectEntryFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,341 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    bundleEffectEntryForNode: ()=>bundleEffectEntryForNode,
+    loadEffectBuiltModule: ()=>loadEffectBuiltModule,
+    loadEffectSourceModule: ()=>loadEffectSourceModule
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+var external_node_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_node_crypto_namespaceObject);
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const external_esbuild_namespaceObject = require("esbuild");
+const NODE_TARGET = 'node26.7';
+const SOURCE_LOADERS = new Map([
+    [
+        '.js',
+        'js'
+    ],
+    [
+        '.jsx',
+        'jsx'
+    ],
+    [
+        '.mjs',
+        'js'
+    ],
+    [
+        '.cjs',
+        'js'
+    ],
+    [
+        '.ts',
+        'ts'
+    ],
+    [
+        '.tsx',
+        'tsx'
+    ],
+    [
+        '.mts',
+        'ts'
+    ],
+    [
+        '.cts',
+        'ts'
+    ]
+]);
+function sourceLoader(args) {
+    return SOURCE_LOADERS.get(external_node_path_default().extname(args.path).toLowerCase());
+}
+function preserveSourceModuleSemantics() {
+    return {
+        name: 'modern-js-effect-source-semantics',
+        setup (buildApi) {
+            buildApi.onLoad({
+                filter: /\.[cm]?[jt]sx?$/
+            }, async (args)=>{
+                const loader = sourceLoader(args);
+                if (!loader) return;
+                const source = await external_node_fs_default().promises.readFile(args.path, 'utf8');
+                const compiled = await (0, external_esbuild_namespaceObject.transform)(source, {
+                    define: {
+                        'import.meta.url': JSON.stringify((0, external_node_url_namespaceObject.pathToFileURL)(args.path).href)
+                    },
+                    jsx: 'automatic',
+                    loader,
+                    sourcefile: args.path,
+                    target: NODE_TARGET
+                });
+                return {
+                    contents: compiled.code,
+                    loader: 'js',
+                    resolveDir: external_node_path_default().dirname(args.path)
+                };
+            });
+        }
+    };
+}
+const nodeBuiltins = new Set([
+    ...external_node_module_namespaceObject.builtinModules,
+    ...external_node_module_namespaceObject.builtinModules.map((name)=>`node:${name}`)
+]);
+const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
+async function isEsmOnlyFile(filename) {
+    const extension = external_node_path_default().extname(filename).toLowerCase();
+    if ('.mjs' === extension || '.mts' === extension) return true;
+    if ('.cjs' === extension || '.cts' === extension) return false;
+    let directory = external_node_path_default().dirname(filename);
+    while(true){
+        const packagePath = external_node_path_default().join(directory, 'package.json');
+        try {
+            const packageJson = JSON.parse(await external_node_fs_default().promises.readFile(packagePath, 'utf8'));
+            return 'module' === packageJson.type;
+        } catch (error) {
+            if (!error || 'object' != typeof error || !('code' in error) || 'ENOENT' !== error.code) throw error;
+        }
+        const parent = external_node_path_default().dirname(directory);
+        if (parent === directory) return false;
+        directory = parent;
+    }
+}
+function isBareSpecifier(specifier) {
+    return !specifier.startsWith('.') && !specifier.startsWith('/') && !external_node_path_default().isAbsolute(specifier);
+}
+function externalizeInstalledDependencies(options) {
+    const runtimeRequire = (0, external_node_module_namespaceObject.createRequire)(external_node_path_default().join(options.runtimeResolveDir, '__modern_effect_entry.cjs'));
+    return {
+        name: 'modern-js-effect-installed-dependencies',
+        setup (buildApi) {
+            buildApi.onResolve({
+                filter: /.*/
+            }, async (args)=>{
+                if (!isBareSpecifier(args.path) || nodeBuiltins.has(args.path) || args.pluginData?.[dependencyResolutionMarker] === true) return nodeBuiltins.has(args.path) ? {
+                    external: true,
+                    path: args.path
+                } : void 0;
+                const resolution = await buildApi.resolve(args.path, {
+                    importer: args.importer,
+                    kind: args.kind,
+                    namespace: args.namespace,
+                    pluginData: {
+                        ...args.pluginData,
+                        [dependencyResolutionMarker]: true
+                    },
+                    resolveDir: args.resolveDir
+                });
+                if (resolution.errors.length > 0) return {
+                    external: true,
+                    path: args.path
+                };
+                if (resolution.external || !resolution.path) return {
+                    external: true,
+                    path: args.path
+                };
+                const realPath = await external_node_fs_default().promises.realpath(resolution.path).catch(()=>resolution.path);
+                if (realPath.includes(`${external_node_path_default().sep}node_modules${external_node_path_default().sep}`)) {
+                    const runtimeResolution = await buildApi.resolve(args.path, {
+                        importer: '',
+                        kind: args.kind,
+                        namespace: 'file',
+                        pluginData: {
+                            [dependencyResolutionMarker]: true
+                        },
+                        resolveDir: options.runtimeResolveDir
+                    });
+                    if (0 === runtimeResolution.errors.length && runtimeResolution.path) {
+                        if ('cjs' === options.format) {
+                            let requiredPath;
+                            try {
+                                requiredPath = runtimeRequire.resolve(args.path);
+                            } catch  {
+                                requiredPath = runtimeResolution.path;
+                            }
+                            if (await isEsmOnlyFile(requiredPath)) return {
+                                namespace: resolution.namespace,
+                                path: resolution.path,
+                                pluginData: resolution.pluginData,
+                                sideEffects: resolution.sideEffects,
+                                suffix: resolution.suffix,
+                                warnings: resolution.warnings
+                            };
+                        }
+                        return {
+                            external: true,
+                            path: args.path
+                        };
+                    }
+                }
+                return {
+                    namespace: resolution.namespace,
+                    path: resolution.path,
+                    pluginData: resolution.pluginData,
+                    sideEffects: resolution.sideEffects,
+                    suffix: resolution.suffix,
+                    warnings: resolution.warnings
+                };
+            });
+        }
+    };
+}
+async function bundleEffectEntryForNode(options) {
+    await (0, external_esbuild_namespaceObject.build)({
+        absWorkingDir: options.appDir,
+        allowOverwrite: true,
+        bundle: true,
+        entryPoints: [
+            options.entryPath
+        ],
+        format: options.format,
+        logLevel: 'silent',
+        outfile: options.entryPath,
+        platform: 'node',
+        plugins: [
+            externalizeInstalledDependencies({
+                format: options.format,
+                runtimeResolveDir: options.appDir
+            }),
+            preserveSourceModuleSemantics()
+        ],
+        target: NODE_TARGET
+    });
+}
+function isWatchableInput(filename) {
+    return !filename.includes(`${external_node_path_default().sep}node_modules${external_node_path_default().sep}`) && (SOURCE_LOADERS.has(external_node_path_default().extname(filename).toLowerCase()) || '.json' === external_node_path_default().extname(filename).toLowerCase());
+}
+function normalizeImportedModule(module) {
+    if (!module || 'object' != typeof module) return module;
+    const namespace = module;
+    const commonJsModule = namespace.default;
+    if (1 === Object.keys(namespace).length && null !== commonJsModule && 'object' == typeof commonJsModule && true === commonJsModule.__esModule) return commonJsModule;
+    return module;
+}
+function hasErrorCode(error, code) {
+    return null !== error && 'object' == typeof error && 'code' in error && error.code === code;
+}
+async function publishImmutableOutput(options) {
+    const revision = external_node_crypto_default().createHash('sha256').update(options.contents).digest('hex');
+    const outputPath = external_node_path_default().join(options.cacheDirectory, `${options.outputName}-${revision}.mjs`);
+    const temporaryPath = external_node_path_default().join(options.cacheDirectory, `.${options.outputName}-${external_node_crypto_default().randomUUID()}.tmp`);
+    try {
+        await external_node_fs_default().promises.writeFile(temporaryPath, options.contents, {
+            flag: 'wx'
+        });
+        try {
+            await external_node_fs_default().promises.link(temporaryPath, outputPath);
+        } catch (error) {
+            if (!hasErrorCode(error, 'EEXIST')) throw error;
+            const publishedContents = await external_node_fs_default().promises.readFile(outputPath);
+            if (!publishedContents.equals(Buffer.from(options.contents))) throw new Error(`Effect source cache entry does not match its content address: ${outputPath}`);
+        }
+    } finally{
+        await external_node_fs_default().promises.rm(temporaryPath, {
+            force: true
+        });
+    }
+    return outputPath;
+}
+async function loadEffectBuiltModule(resourcePath) {
+    const canonicalPath = await external_node_fs_default().promises.realpath(external_node_path_default().resolve(resourcePath));
+    if (!await isEsmOnlyFile(canonicalPath)) return (0, external_node_module_namespaceObject.createRequire)(canonicalPath)(canonicalPath);
+    return normalizeImportedModule(await import((0, external_node_url_namespaceObject.pathToFileURL)(canonicalPath).href));
+}
+async function loadEffectSourceModule(options) {
+    const resourcePath = external_node_path_default().resolve(options.resourcePath);
+    const appDir = external_node_path_default().resolve(options.appDir ?? external_node_path_default().dirname(resourcePath));
+    const tsconfigPath = external_node_path_default().join(appDir, 'tsconfig.json');
+    const cacheDirectory = external_node_path_default().join(appDir, 'node_modules', '.cache', 'modern-js', 'effect-source-loader');
+    const outputName = external_node_crypto_default().createHash('sha256').update(resourcePath).digest('hex').slice(0, 24);
+    await external_node_fs_default().promises.mkdir(cacheDirectory, {
+        recursive: true
+    });
+    const result = await (0, external_esbuild_namespaceObject.build)({
+        absWorkingDir: appDir,
+        banner: {
+            js: `import { createRequire as __modernCreateEffectRequire } from 'node:module'; const require = __modernCreateEffectRequire(${JSON.stringify((0, external_node_url_namespaceObject.pathToFileURL)(resourcePath).href)});`
+        },
+        bundle: true,
+        entryPoints: [
+            resourcePath
+        ],
+        format: 'esm',
+        jsx: 'automatic',
+        logLevel: 'silent',
+        metafile: true,
+        outfile: external_node_path_default().join(cacheDirectory, `${outputName}.mjs`),
+        platform: 'node',
+        plugins: [
+            externalizeInstalledDependencies({
+                format: 'esm',
+                runtimeResolveDir: appDir
+            }),
+            preserveSourceModuleSemantics()
+        ],
+        sourcemap: 'inline',
+        target: NODE_TARGET,
+        tsconfig: external_node_fs_default().existsSync(tsconfigPath) ? tsconfigPath : void 0,
+        write: false
+    });
+    for (const input of Object.keys(result.metafile.inputs)){
+        const dependency = external_node_path_default().isAbsolute(input) ? external_node_path_default().normalize(input) : external_node_path_default().resolve(appDir, input);
+        if (isWatchableInput(dependency)) options.onDependency?.(dependency);
+    }
+    if (1 !== result.outputFiles.length) throw new Error(`Expected one Effect source output, received ${result.outputFiles.length}`);
+    const outputPath = await publishImmutableOutput({
+        cacheDirectory,
+        contents: result.outputFiles[0].contents,
+        outputName
+    });
+    return normalizeImportedModule(await import((0, external_node_url_namespaceObject.pathToFileURL)(outputPath).href));
+}
+exports.bundleEffectEntryForNode = __webpack_exports__.bundleEffectEntryForNode;
+exports.loadEffectBuiltModule = __webpack_exports__.loadEffectBuiltModule;
+exports.loadEffectSourceModule = __webpack_exports__.loadEffectSourceModule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "bundleEffectEntryForNode",
+    "loadEffectBuiltModule",
+    "loadEffectSourceModule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect-source-loader/worker-runtime-wrapper.js

@@ -0,0 +1,97 @@
+"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__);
+async function generateEffectWorkerRuntimeWrapper(loader, options, resourcePath) {
+    const { generateEffectClient } = await import("../client-generator/generator.js");
+    const artifacts = await generateEffectClient({
+        appDir: options.appDir,
+        apiDir: options.apiDir,
+        resourcePath,
+        prefix: options.prefix,
+        port: Number(options.port),
+        target: 'bundle',
+        requestId: options.requestId,
+        requestCreator: options.requestCreator,
+        httpMethodDecider: options.httpMethodDecider,
+        dataPlatformBatch: options.effectDataPlatformBatch,
+        onDependency: (dependency)=>loader.addDependency(dependency)
+    });
+    const sourceRequest = `${resourcePath}?modern-bff-runtime-source`;
+    const operationContracts = artifacts?.operationContracts ?? {};
+    return `import * as effectBffModule from ${JSON.stringify(sourceRequest)};
+import { createEffectBffEdgeDispatcher } from '@modern-js/plugin-bff/effect-edge/dispatcher';
+
+const __generatedOperationContracts = ${JSON.stringify(operationContracts)};
+
+const __mergeGeneratedOperationContracts = policy => {
+  if (
+    !policy ||
+    !policy.expectedOperationContracts ||
+    typeof policy.expectedOperationContracts !== 'object' ||
+    Array.isArray(policy.expectedOperationContracts)
+  ) {
+    return policy;
+  }
+  return {
+    ...policy,
+    expectedOperationContracts: {
+      ...policy.expectedOperationContracts,
+      ...__generatedOperationContracts,
+    },
+  };
+};
+
+export const __modern_create_effect_bff_dispatcher = options =>
+  createEffectBffEdgeDispatcher({
+    ...options,
+    crossProjectPolicy: __mergeGeneratedOperationContracts(
+      options?.crossProjectPolicy,
+    ),
+    module: effectBffModule,
+  });
+`;
+}
+async function generateEffectClientCode(options) {
+    const { generateEffectClient } = await import("../client-generator/generator.js");
+    const artifacts = await generateEffectClient(options);
+    return null === artifacts ? null : artifacts.code;
+}
+__webpack_require__.d(__webpack_exports__, {
+    generateEffectClientCode: ()=>generateEffectClientCode,
+    generateEffectWorkerRuntimeWrapper: ()=>generateEffectWorkerRuntimeWrapper
+});
+exports.generateEffectClientCode = __webpack_exports__.generateEffectClientCode;
+exports.generateEffectWorkerRuntimeWrapper = __webpack_exports__.generateEffectWorkerRuntimeWrapper;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateEffectClientCode",
+    "generateEffectWorkerRuntimeWrapper"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});