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

package/dist/esm/effect-source-loader/loader.mjs

@@ -0,0 +1,285 @@
+import node_crypto from "node:crypto";
+import node_fs from "node:fs";
+import { builtinModules, createRequire } from "node:module";
+import node_path from "node:path";
+import { pathToFileURL } from "node:url";
+import { build, transform } from "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(node_path.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 node_fs.promises.readFile(args.path, 'utf8');
+                const compiled = await transform(source, {
+                    define: {
+                        'import.meta.url': JSON.stringify(pathToFileURL(args.path).href)
+                    },
+                    jsx: 'automatic',
+                    loader,
+                    sourcefile: args.path,
+                    target: NODE_TARGET
+                });
+                return {
+                    contents: compiled.code,
+                    loader: 'js',
+                    resolveDir: node_path.dirname(args.path)
+                };
+            });
+        }
+    };
+}
+const nodeBuiltins = new Set([
+    ...builtinModules,
+    ...builtinModules.map((name)=>`node:${name}`)
+]);
+const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
+async function isEsmOnlyFile(filename) {
+    const extension = node_path.extname(filename).toLowerCase();
+    if ('.mjs' === extension || '.mts' === extension) return true;
+    if ('.cjs' === extension || '.cts' === extension) return false;
+    let directory = node_path.dirname(filename);
+    while(true){
+        const packagePath = node_path.join(directory, 'package.json');
+        try {
+            const packageJson = JSON.parse(await node_fs.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 = node_path.dirname(directory);
+        if (parent === directory) return false;
+        directory = parent;
+    }
+}
+function isBareSpecifier(specifier) {
+    return !specifier.startsWith('.') && !specifier.startsWith('/') && !node_path.isAbsolute(specifier);
+}
+function externalizeInstalledDependencies(options) {
+    const runtimeRequire = createRequire(node_path.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 node_fs.promises.realpath(resolution.path).catch(()=>resolution.path);
+                if (realPath.includes(`${node_path.sep}node_modules${node_path.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 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(`${node_path.sep}node_modules${node_path.sep}`) && (SOURCE_LOADERS.has(node_path.extname(filename).toLowerCase()) || '.json' === node_path.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 = node_crypto.createHash('sha256').update(options.contents).digest('hex');
+    const outputPath = node_path.join(options.cacheDirectory, `${options.outputName}-${revision}.mjs`);
+    const temporaryPath = node_path.join(options.cacheDirectory, `.${options.outputName}-${node_crypto.randomUUID()}.tmp`);
+    try {
+        await node_fs.promises.writeFile(temporaryPath, options.contents, {
+            flag: 'wx'
+        });
+        try {
+            await node_fs.promises.link(temporaryPath, outputPath);
+        } catch (error) {
+            if (!hasErrorCode(error, 'EEXIST')) throw error;
+            const publishedContents = await node_fs.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 node_fs.promises.rm(temporaryPath, {
+            force: true
+        });
+    }
+    return outputPath;
+}
+async function loadEffectBuiltModule(resourcePath) {
+    const canonicalPath = await node_fs.promises.realpath(node_path.resolve(resourcePath));
+    if (!await isEsmOnlyFile(canonicalPath)) return createRequire(canonicalPath)(canonicalPath);
+    return normalizeImportedModule(await import(pathToFileURL(canonicalPath).href));
+}
+async function loadEffectSourceModule(options) {
+    const resourcePath = node_path.resolve(options.resourcePath);
+    const appDir = node_path.resolve(options.appDir ?? node_path.dirname(resourcePath));
+    const tsconfigPath = node_path.join(appDir, 'tsconfig.json');
+    const cacheDirectory = node_path.join(appDir, 'node_modules', '.cache', 'modern-js', 'effect-source-loader');
+    const outputName = node_crypto.createHash('sha256').update(resourcePath).digest('hex').slice(0, 24);
+    await node_fs.promises.mkdir(cacheDirectory, {
+        recursive: true
+    });
+    const result = await build({
+        absWorkingDir: appDir,
+        banner: {
+            js: `import { createRequire as __modernCreateEffectRequire } from 'node:module'; const require = __modernCreateEffectRequire(${JSON.stringify(pathToFileURL(resourcePath).href)});`
+        },
+        bundle: true,
+        entryPoints: [
+            resourcePath
+        ],
+        format: 'esm',
+        jsx: 'automatic',
+        logLevel: 'silent',
+        metafile: true,
+        outfile: node_path.join(cacheDirectory, `${outputName}.mjs`),
+        platform: 'node',
+        plugins: [
+            externalizeInstalledDependencies({
+                format: 'esm',
+                runtimeResolveDir: appDir
+            }),
+            preserveSourceModuleSemantics()
+        ],
+        sourcemap: 'inline',
+        target: NODE_TARGET,
+        tsconfig: node_fs.existsSync(tsconfigPath) ? tsconfigPath : void 0,
+        write: false
+    });
+    for (const input of Object.keys(result.metafile.inputs)){
+        const dependency = node_path.isAbsolute(input) ? node_path.normalize(input) : node_path.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(pathToFileURL(outputPath).href));
+}
+export { bundleEffectEntryForNode, loadEffectBuiltModule, loadEffectSourceModule };

package/dist/esm/effect-source-loader/worker-runtime-wrapper.mjs

@@ -0,0 +1,56 @@
+async function generateEffectWorkerRuntimeWrapper(loader, options, resourcePath) {
+    const { generateEffectClient } = await import("../client-generator/generator.mjs");
+    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.mjs");
+    const artifacts = await generateEffectClient(options);
+    return null === artifacts ? null : artifacts.code;
+}
+export { generateEffectClientCode, generateEffectWorkerRuntimeWrapper };

package/dist/esm/hono/bind-route-handlers.mjs

@@ -0,0 +1,38 @@
+import { createSafeFailureResponse } from "@modern-js/runtime-extensions/safe-failure";
+import { createHonoCrossProjectPolicyMiddleware } from "./cross-project-policy.mjs";
+const bindHonoRouteHandlers = ({ handler, policy, routePath, onError, reportError })=>{
+    const handlers = Array.isArray(handler) ? handler : [
+        handler
+    ];
+    const [firstHandler, ...restHandlers] = handlers;
+    let routeHandlers = handler;
+    if (firstHandler) {
+        const errorBoundary = async (context, next)=>{
+            try {
+                return await firstHandler(context, next);
+            } catch (error) {
+                try {
+                    if (onError) {
+                        const result = await onError(error, context);
+                        if (result instanceof Response) return result;
+                    } else reportError?.(error);
+                } catch (configError) {
+                    reportError?.(`Error in serverConfig.onError handler: ${configError}`);
+                }
+                return createSafeFailureResponse(error);
+            }
+        };
+        routeHandlers = Array.isArray(handler) ? [
+            errorBoundary,
+            ...restHandlers
+        ] : errorBoundary;
+    }
+    if (!policy) return routeHandlers;
+    return [
+        createHonoCrossProjectPolicyMiddleware(policy, routePath),
+        ...Array.isArray(routeHandlers) ? routeHandlers : [
+            routeHandlers
+        ]
+    ];
+};
+export { bindHonoRouteHandlers };

package/dist/esm/hono/cross-project-policy.mjs

@@ -0,0 +1,10 @@
+import { checkCrossProjectPolicyResponse } from "../cross-project-policy/evaluation.mjs";
+const createHonoCrossProjectPolicyMiddleware = (policy, routePath)=>async function(context, next) {
+        const denial = checkCrossProjectPolicyResponse(context.req.header(), policy, {
+            method: context.req.method,
+            routePath
+        });
+        if (denial) return denial;
+        return next();
+    };
+export { createHonoCrossProjectPolicyMiddleware };

package/dist/esm/hono/index.mjs

@@ -0,0 +1 @@
+export { bindHonoRouteHandlers } from "./bind-route-handlers.mjs";

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

@@ -0,0 +1,187 @@
+import "node:module";
+import { validateLoadedBackendFederatedEffectApi } from "./validate-loaded.mjs";
+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;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function parseRemoteRequest(request) {
+    const separator = request.indexOf('/');
+    if (separator <= 0 || separator === request.length - 1) throw new Error(`[BFF][Effect] Invalid backend federation request ${request}.`);
+    return {
+        expose: `./${request.slice(separator + 1).replace(/^\.\//u, '')}`,
+        remoteName: request.slice(0, separator)
+    };
+}
+function requireEdgeRemote(remotes, remoteName) {
+    const remote = remotes.find((candidate)=>candidate.name === remoteName);
+    if (void 0 === remote) throw new Error(`[BFF][Effect] Missing backend federation remote ${remoteName}.`);
+    if (!/^(?:binding|service|static):/u.test(remote.entry)) throw new Error(`[BFF][Effect] Edge backend federation remote ${remote.name} must use static or service-binding entries.`);
+    return remote;
+}
+async function resolveEdgeEntry(plugins, remote) {
+    for (const plugin of plugins){
+        const entry = await plugin.loadEntry?.({
+            remoteInfo: remote
+        });
+        if (void 0 !== entry) return entry;
+    }
+    if (remote.entry.startsWith('static:') && remote.entryGlobalName) {
+        const globalEntry = globalThis[remote.entryGlobalName];
+        if ('object' == typeof globalEntry && null !== globalEntry) return globalEntry;
+        throw new Error(`[BFF][Effect] Missing static backend federation entry global ${remote.entryGlobalName} for remote ${remote.name}.`);
+    }
+    throw new Error(`[BFF][Effect] Missing static or service-binding entry provider for backend federation remote ${remote.name}.`);
+}
+var _entries = /*#__PURE__*/ new WeakMap(), _expected = /*#__PURE__*/ new WeakMap(), _hostName = /*#__PURE__*/ new WeakMap(), _allowMissingIdentityMetadata = /*#__PURE__*/ new WeakMap(), _modules = /*#__PURE__*/ new WeakMap(), _plugins = /*#__PURE__*/ new WeakMap(), _remotes = /*#__PURE__*/ new WeakMap(), _loadEntry = /*#__PURE__*/ new WeakSet(), _loadModule = /*#__PURE__*/ new WeakSet();
+class EdgeBackendFederationRuntime {
+    async loadRemote(request) {
+        const existing = _class_private_field_get(this, _modules).get(request);
+        if (void 0 !== existing) return existing;
+        const loading = _class_private_method_get(this, _loadModule, loadModule).call(this, request);
+        _class_private_field_get(this, _modules).set(request, loading);
+        loading.catch(()=>{
+            if (_class_private_field_get(this, _modules).get(request) === loading) _class_private_field_get(this, _modules).delete(request);
+        });
+        return loading;
+    }
+    constructor(options){
+        _class_private_method_init(this, _loadEntry);
+        _class_private_method_init(this, _loadModule);
+        _class_private_field_init(this, _entries, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _expected, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _hostName, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _allowMissingIdentityMetadata, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _modules, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _plugins, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _remotes, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _entries, new Map());
+        _class_private_field_set(this, _modules, new Map());
+        if (void 0 !== options.entryPolicy) throw new Error('[BFF][Effect] Edge backend federation does not execute entry evaluators. Register a static or service-binding entry provider.');
+        _class_private_field_set(this, _allowMissingIdentityMetadata, true === options.allowMissingIdentityMetadata);
+        _class_private_field_set(this, _expected, options.expected);
+        _class_private_field_set(this, _hostName, options.hostName);
+        _class_private_field_set(this, _plugins, options.plugins ?? []);
+        _class_private_field_set(this, _remotes, [
+            ...options.remotes ?? []
+        ]);
+        const configuredRemote = options.remote;
+        if (void 0 !== configuredRemote) {
+            const existingIndex = _class_private_field_get(this, _remotes).findIndex((remote)=>remote.name === configuredRemote.name);
+            if (existingIndex >= 0) _class_private_field_get(this, _remotes)[existingIndex] = configuredRemote;
+            else _class_private_field_get(this, _remotes).push(configuredRemote);
+        }
+    }
+}
+function loadEntry(remote) {
+    const existing = _class_private_field_get(this, _entries).get(remote.name);
+    if (void 0 !== existing) return existing;
+    const loading = resolveEdgeEntry(_class_private_field_get(this, _plugins), remote).then(async (entry)=>{
+        await entry.init?.({
+            hostName: _class_private_field_get(this, _hostName)
+        });
+        return entry;
+    });
+    _class_private_field_get(this, _entries).set(remote.name, loading);
+    loading.catch(()=>{
+        if (_class_private_field_get(this, _entries).get(remote.name) === loading) _class_private_field_get(this, _entries).delete(remote.name);
+    });
+    return loading;
+}
+function loadModule(request) {
+    const { expose, remoteName } = parseRemoteRequest(request);
+    const remote = requireEdgeRemote(_class_private_field_get(this, _remotes), remoteName);
+    return _class_private_method_get(this, _loadEntry, loadEntry).call(this, remote).then(async (entry)=>{
+        if ('function' != typeof entry.get) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} entry must expose get().`);
+        const factory = await entry.get(expose);
+        if ('function' != typeof factory) throw new Error(`[BFF][Effect] Backend federation expose ${remote.name}/${expose.replace(/^\.\//u, '')} must load factory function.`);
+        const loaded = await factory();
+        return validateLoadedBackendFederatedEffectApi(loaded, {
+            allowMissingIdentityMetadata: _class_private_field_get(this, _allowMissingIdentityMetadata),
+            expected: _class_private_field_get(this, _expected),
+            remoteName,
+            remoteRequest: request
+        });
+    });
+}
+function createBackendFederationLoadEntryPlugin(options) {
+    return {
+        name: 'modernjs-backend-federation-load-entry',
+        loadEntry ({ remoteInfo }) {
+            return Promise.resolve(options.resolveEntry(remoteInfo)).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);
+                    }
+                };
+            });
+        }
+    };
+}
+function createBackendFederationRuntime(options) {
+    if (void 0 === options.expected || 'string' != typeof options.expected.unitId || 0 === options.expected.unitId.length || 'string' != typeof options.expected.buildMarker || 0 === options.expected.buildMarker.length) throw new Error('[BFF][Effect] Edge backend federation runtime requires expected.unitId and expected.buildMarker.');
+    return new EdgeBackendFederationRuntime(options);
+}
+function createBackendFederationRuntimeForLoad(options) {
+    return new EdgeBackendFederationRuntime(options);
+}
+export { createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, createBackendFederationRuntimeForLoad };

package/dist/esm-node/backend-federation/edge.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "@modern-js/utils/universal";
+import { createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, createBackendFederationRuntimeForLoad } from "./edge-runtime.mjs";
+import { LEGACY_LOAD_WARNING } from "./legacy-warning.mjs";
+import { normalizeExpose } from "./utils.mjs";
+function loadBackendFederatedEffectApi(options) {
+    if (void 0 !== options.runtime || void 0 !== options.entryPolicy) return Promise.reject(new Error('[BFF][Effect] Edge backend federation does not execute custom runtimes or entry evaluators. Register a static or service-binding entry provider.'));
+    const remoteName = options.remote?.name ?? options.remoteName;
+    if (void 0 === remoteName || 0 === remoteName.length) return Promise.reject(new Error('[BFF][Effect] Missing backend federation remote name.'));
+    if (void 0 === options.expected) console.warn(LEGACY_LOAD_WARNING);
+    const expose = options.expose ?? options.remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE;
+    const remoteRequest = `${remoteName}/${normalizeExpose(expose)}`;
+    let runtime;
+    try {
+        runtime = createBackendFederationRuntimeForLoad(options);
+    } catch (error) {
+        return Promise.reject(error);
+    }
+    return runtime.loadRemote(remoteRequest);
+}
+export { validateExpectedBackendFederationIdentity } from "./identity.mjs";
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, loadBackendFederatedEffectApi };

package/dist/esm-node/backend-federation/entry.mjs

@@ -0,0 +1,57 @@
+import "node:module";
+import { evaluateBackendFederationCommonJsEntry, loadVerifiedBackendFederationEntry } from "@modern-js/server-runtime-extensions/backend-federation-security";
+import { isRecord, normalizeExpose } from "./utils.mjs";
+function decodeDataUrl(url) {
+    const commaIndex = url.indexOf(',');
+    if (commaIndex < 0) throw new Error('[BFF][Effect] Invalid backend federation data URL entry.');
+    return decodeURIComponent(url.slice(commaIndex + 1));
+}
+async function readCommonJsEntrySource(remote) {
+    if (remote.entry.startsWith('data:')) return decodeDataUrl(remote.entry);
+    throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} cannot load CommonJS entry ${remote.entry}.`);
+}
+async function importModuleEntry(remote) {
+    const entry = await import(remote.entry);
+    return entry.default ?? entry;
+}
+async function resolvePluginEntry(remote, plugins) {
+    for (const plugin of plugins ?? []){
+        const loadEntry = plugin.loadEntry;
+        if ('function' != typeof loadEntry) continue;
+        const entry = await loadEntry({
+            remoteInfo: remote
+        });
+        if (entry) return entry;
+    }
+}
+async function loadBackendFederationEntry(remote, options) {
+    const requiresVerification = Boolean(remote.verification || options.entryPolicy?.expected);
+    const isNetworkEntry = /^https?:\/\//iu.test(remote.entry);
+    if (isNetworkEntry && !requiresVerification) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} requires verified entry bytes before network execution.`);
+    if (requiresVerification) return loadVerifiedBackendFederationEntry({
+        ...options.entryPolicy,
+        remote,
+        ...remote.verification ? {
+            verification: remote.verification
+        } : {}
+    });
+    const pluginEntry = await resolvePluginEntry(remote, options.plugins);
+    if (pluginEntry) return pluginEntry;
+    if (remote.entryGlobalName) {
+        const globalEntry = globalThis[remote.entryGlobalName];
+        if (isRecord(globalEntry)) return globalEntry;
+    }
+    if ('module' === remote.type || remote.entry.startsWith('file:')) return importModuleEntry(remote);
+    return evaluateBackendFederationCommonJsEntry(remote, new TextEncoder().encode(await readCommonJsEntrySource(remote)), options.entryPolicy?.evaluateCommonJs);
+}
+async function loadBackendFederationExpose(remote, expose, options) {
+    const entry = await loadBackendFederationEntry(remote, options);
+    if ('function' == typeof entry.init) await entry.init({
+        hostName: options.hostName
+    });
+    if ('function' != typeof entry.get) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} entry must expose get().`);
+    const factory = await entry.get(expose);
+    if ('function' != typeof factory) throw new Error(`[BFF][Effect] Backend federation expose ${remote.name}/${normalizeExpose(expose)} must load factory function.`);
+    return factory();
+}
+export { loadBackendFederationExpose };