@bleedingdev/modern-js-plugin-bff 3.8.2-ultramodern.9 → 3.8.3-ultramodern.2

package/dist/esm-node/runtime/data-platform/codec.mjs

@@ -1,91 +0,0 @@
-import "node:module";
-function isPlainObject(value) {
-    if ('object' != typeof value || null === value || Array.isArray(value)) return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || null === proto;
-}
-function canonicalize(value) {
-    if (Array.isArray(value)) return value.map((item)=>canonicalize(item));
-    if (isPlainObject(value)) return Object.keys(value).sort().reduce((acc, key)=>{
-        acc[key] = canonicalize(value[key]);
-        return acc;
-    }, {});
-    return value;
-}
-function stableStringify(value) {
-    return JSON.stringify(canonicalize(value));
-}
-function encodeRequestEnvelopeHeader(envelope) {
-    return encodeURIComponent(stableStringify(envelope));
-}
-function isRequestEnvelopeShape(value) {
-    if (!isPlainObject(value)) return false;
-    return 1 === value.protocolVersion && 'string' == typeof value.operationId && 'string' == typeof value.appNamespace && 'string' == typeof value.origin && 'string' == typeof value.scopeKey && 'string' == typeof value.inputHash && 'number' == typeof value.timestamp;
-}
-function decodeRequestEnvelopeHeader(value) {
-    try {
-        const decoded = decodeURIComponent(value);
-        const parsed = JSON.parse(decoded);
-        if (!isRequestEnvelopeShape(parsed)) return null;
-        return parsed;
-    } catch  {
-        return null;
-    }
-}
-function hashString(value) {
-    let hash = 0x811c9dc5;
-    for(let index = 0; index < value.length; index++){
-        hash ^= value.charCodeAt(index);
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return (hash >>> 0).toString(16).padStart(8, '0');
-}
-function sanitizeSegment(segment) {
-    const normalized = segment.trim().replace(/[^a-zA-Z0-9_-]+/g, '_');
-    return normalized.length > 0 ? normalized : 'unknown';
-}
-function normalizeOrigin(origin) {
-    const normalized = origin.trim();
-    try {
-        const url = new URL(normalized);
-        return `${url.protocol}//${url.host}`.toLowerCase();
-    } catch  {
-        return normalized.toLowerCase();
-    }
-}
-function normalizeOperationDescriptor(input) {
-    return {
-        appNamespace: sanitizeSegment(input.appNamespace),
-        apiId: sanitizeSegment(input.apiId),
-        group: sanitizeSegment(input.group),
-        endpoint: sanitizeSegment(input.endpoint),
-        schemaHash: input.schemaHash || null,
-        version: input.version ?? 1
-    };
-}
-function createOperationId(input) {
-    const descriptor = normalizeOperationDescriptor(input);
-    const readable = `${descriptor.appNamespace}.${descriptor.apiId}.${descriptor.group}.${descriptor.endpoint}.v${String(descriptor.version)}`;
-    return `${readable}:${hashString(stableStringify(descriptor))}`;
-}
-function buildScopeKey(scope) {
-    const canonical = {
-        appNamespace: sanitizeSegment(scope.appNamespace),
-        origin: normalizeOrigin(scope.origin),
-        tenantId: scope.tenantId ?? null,
-        userId: scope.userId ?? null,
-        sessionId: scope.sessionId ?? null
-    };
-    return `${canonical.appNamespace}:${hashString(stableStringify(canonical))}`;
-}
-function buildQueryKey(input) {
-    const canonical = {
-        operationId: input.operationId,
-        scopeKey: input.scopeKey,
-        requestMode: input.requestMode ?? 'cache-first',
-        requestInput: input.requestInput ?? null,
-        selectionPlan: input.selectionPlan ?? null
-    };
-    return `${input.operationId}:${hashString(stableStringify(canonical))}`;
-}
-export { buildQueryKey, buildScopeKey, createOperationId, decodeRequestEnvelopeHeader, encodeRequestEnvelopeHeader, hashString, isPlainObject, normalizeOrigin, sanitizeSegment, stableStringify };

package/dist/esm-node/runtime/data-platform/invalidation.mjs

@@ -1,21 +0,0 @@
-import "node:module";
-import { buildScopeKey, createOperationId, sanitizeSegment } from "./codec.mjs";
-function createInvalidationEvent(input) {
-    return {
-        sourceNamespace: sanitizeSegment(input.sourceOperation.appNamespace),
-        sourceOperationId: createOperationId(input.sourceOperation),
-        scopeKey: buildScopeKey(input.sourceScope),
-        targetNamespaces: input.targetNamespaces?.map((namespace)=>sanitizeSegment(namespace)),
-        targetOperationIds: input.targetOperations?.map((operation)=>createOperationId(operation))
-    };
-}
-function shouldApplyInvalidation(event, subscriber) {
-    if (subscriber.scopeKey && subscriber.scopeKey !== event.scopeKey) return false;
-    const sameNamespace = subscriber.namespace === event.sourceNamespace;
-    const allowedCrossNamespace = true === subscriber.acceptCrossNamespace && event.targetNamespaces?.includes(subscriber.namespace) === true;
-    if (!sameNamespace && !allowedCrossNamespace) return false;
-    if (!subscriber.operationIds || 0 === subscriber.operationIds.length) return true;
-    if (!event.targetOperationIds || 0 === event.targetOperationIds.length) return true;
-    return subscriber.operationIds.some((operationId)=>event.targetOperationIds?.includes(operationId));
-}
-export { createInvalidationEvent, shouldApplyInvalidation };

package/dist/esm-node/runtime/data-platform/trace.mjs

@@ -1,30 +0,0 @@
-import "node:module";
-import { parseTraceparent } from "@modern-js/create-request";
-function isAllZeroHex(value) {
-    return /^0+$/.test(value);
-}
-function isValidHex(value, length) {
-    return value.length === length && /^[0-9a-f]+$/.test(value);
-}
-function parseTraceparentHeader(header) {
-    return parseTraceparent(header) ?? null;
-}
-function formatTraceparentHeader(trace) {
-    const traceId = trace.traceId.toLowerCase();
-    const spanId = trace.spanId.toLowerCase();
-    if (!isValidHex(traceId, 32) || !isValidHex(spanId, 16)) throw new Error('Invalid trace context: traceId/spanId format mismatch');
-    if (isAllZeroHex(traceId) || isAllZeroHex(spanId)) throw new Error('Invalid trace context: traceId/spanId cannot be zero');
-    const flags = trace.sampled ? '01' : '00';
-    return `00-${traceId}-${spanId}-${flags}`;
-}
-function deriveChildTraceContext(parent, childSpanId) {
-    const normalizedSpanId = childSpanId.toLowerCase();
-    if (!isValidHex(normalizedSpanId, 16) || isAllZeroHex(normalizedSpanId)) throw new Error('Invalid child span id');
-    return {
-        traceId: parent.traceId.toLowerCase(),
-        spanId: normalizedSpanId,
-        sampled: parent.sampled,
-        parentSpanId: parent.spanId.toLowerCase()
-    };
-}
-export { deriveChildTraceContext, formatTraceparentHeader, parseTraceparentHeader };

package/dist/esm-node/runtime/data-platform/types.mjs

@@ -1,5 +0,0 @@
-import "node:module";
-const DEFAULT_DATA_ENVELOPE_HEADER = 'x-modernjs-data-envelope';
-const DEFAULT_DATA_BATCH_ENDPOINT = '/_data/batch';
-const DEFAULT_DATA_BATCH_HEADER = 'x-modernjs-data-batch';
-export { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER };

package/dist/esm-node/runtime/data-platform/validation.mjs

@@ -1,129 +0,0 @@
-import "node:module";
-import { buildScopeKey, createOperationId, hashString, isPlainObject, normalizeOrigin, sanitizeSegment, stableStringify } from "./codec.mjs";
-import { formatTraceparentHeader, parseTraceparentHeader } from "./trace.mjs";
-function validateSelectionPlan(plan, options = {}) {
-    const maxDepthLimit = options.maxDepth ?? 8;
-    const maxFieldsLimit = options.maxFields ?? 256;
-    const allowedLeafPaths = options.allowedLeafPaths ? new Set(options.allowedLeafPaths) : null;
-    const errors = [];
-    let maxDepth = 0;
-    let fieldCount = 0;
-    const walk = (node, path)=>{
-        if (!isPlainObject(node)) return void errors.push(`Selection node at "${path.join('.') || '<root>'}" must be an object`);
-        const keys = Object.keys(node);
-        if (0 === keys.length) return void errors.push(`Selection node at "${path.join('.') || '<root>'}" cannot be empty`);
-        for (const key of keys){
-            fieldCount += 1;
-            if (fieldCount > maxFieldsLimit) return void errors.push(`Selection has too many fields: ${String(fieldCount)} > ${String(maxFieldsLimit)}`);
-            const nextPath = [
-                ...path,
-                key
-            ];
-            const depth = nextPath.length;
-            if (depth > maxDepth) maxDepth = depth;
-            if (depth > maxDepthLimit) return void errors.push(`Selection exceeds maxDepth at "${nextPath.join('.')}" (${String(depth)} > ${String(maxDepthLimit)})`);
-            const value = node[key];
-            if (true === value) {
-                if (allowedLeafPaths && !allowedLeafPaths.has(nextPath.join('.'))) errors.push(`Unknown selected field "${nextPath.join('.')}"`);
-                continue;
-            }
-            if (!isPlainObject(value)) {
-                errors.push(`Invalid selection value at "${nextPath.join('.')}"; expected true or nested object`);
-                continue;
-            }
-            walk(value, nextPath);
-        }
-    };
-    walk(plan, []);
-    return {
-        ok: 0 === errors.length,
-        errors,
-        stats: {
-            maxDepth,
-            fieldCount
-        }
-    };
-}
-function createRequestEnvelope(input) {
-    if (input.requireTraceContext && !input.traceContext) throw new Error('Trace context is required for this request envelope');
-    const traceparent = input.traceContext ? formatTraceparentHeader(input.traceContext) : void 0;
-    const envelope = {
-        protocolVersion: input.protocolVersion ?? 1,
-        operationId: createOperationId(input.operation),
-        appNamespace: sanitizeSegment(input.scope.appNamespace),
-        origin: normalizeOrigin(input.scope.origin),
-        requestMode: input.requestMode ?? 'cache-first',
-        mutationMode: input.mutationMode,
-        scopeKey: buildScopeKey(input.scope),
-        input: input.requestInput,
-        inputHash: hashString(stableStringify(input.requestInput ?? null)),
-        selectionPlan: input.selectionPlan,
-        selectionHash: input.selectionPlan ? hashString(stableStringify(input.selectionPlan)) : void 0,
-        traceparent,
-        timestamp: input.timestamp ?? Date.now()
-    };
-    return envelope;
-}
-function validateRequestEnvelope(envelope, options = {}) {
-    const errors = [];
-    if (void 0 !== options.expectedProtocolVersion && envelope.protocolVersion !== options.expectedProtocolVersion) errors.push(`Protocol mismatch: expected ${String(options.expectedProtocolVersion)} but received ${String(envelope.protocolVersion)}`);
-    if (options.expectedNamespace && envelope.appNamespace !== options.expectedNamespace) errors.push(`Namespace mismatch: expected ${options.expectedNamespace} but received ${envelope.appNamespace}`);
-    if (options.expectedOrigin) {
-        const expectedOrigin = normalizeOrigin(options.expectedOrigin);
-        if (envelope.origin !== expectedOrigin) errors.push(`Origin mismatch: expected ${expectedOrigin} but received ${envelope.origin}`);
-    }
-    if (!envelope.operationId) errors.push('Missing operationId');
-    if (!envelope.scopeKey) errors.push('Missing scopeKey');
-    if (options.requireTraceContext && !envelope.traceparent) errors.push('Missing trace context');
-    if (envelope.traceparent && !parseTraceparentHeader(envelope.traceparent)) errors.push('Invalid traceparent header');
-    const computedInputHash = hashString(stableStringify(envelope.input ?? null));
-    if (computedInputHash !== envelope.inputHash) errors.push('Input hash mismatch');
-    if (envelope.selectionPlan) {
-        const computedSelectionHash = hashString(stableStringify(envelope.selectionPlan));
-        if (computedSelectionHash !== envelope.selectionHash) errors.push('Selection hash mismatch');
-    }
-    return {
-        ok: 0 === errors.length,
-        errors
-    };
-}
-function createHydrationEnvelope(input) {
-    const envelopeWithoutChecksum = {
-        protocolVersion: input.protocolVersion ?? 1,
-        runtimeVersion: input.runtimeVersion,
-        appNamespace: sanitizeSegment(input.scope.appNamespace),
-        origin: normalizeOrigin(input.scope.origin),
-        createdAt: input.createdAt ?? Date.now(),
-        payload: input.payload
-    };
-    const checksum = hashString(stableStringify(envelopeWithoutChecksum));
-    return {
-        ...envelopeWithoutChecksum,
-        checksum
-    };
-}
-function validateHydrationEnvelope(envelope, options = {}) {
-    const errors = [];
-    if (void 0 !== options.expectedProtocolVersion && envelope.protocolVersion !== options.expectedProtocolVersion) errors.push(`Protocol mismatch: expected ${String(options.expectedProtocolVersion)} but received ${String(envelope.protocolVersion)}`);
-    if (options.expectedNamespace && envelope.appNamespace !== options.expectedNamespace) errors.push(`Namespace mismatch: expected ${options.expectedNamespace} but received ${envelope.appNamespace}`);
-    if (options.expectedOrigin) {
-        const expectedOrigin = normalizeOrigin(options.expectedOrigin);
-        if (envelope.origin !== expectedOrigin) errors.push(`Origin mismatch: expected ${expectedOrigin} but received ${envelope.origin}`);
-    }
-    if (options.expectedRuntimeVersion && envelope.runtimeVersion !== options.expectedRuntimeVersion) errors.push(`Runtime version mismatch: expected ${options.expectedRuntimeVersion} but received ${envelope.runtimeVersion}`);
-    const checksumBase = {
-        protocolVersion: envelope.protocolVersion,
-        runtimeVersion: envelope.runtimeVersion,
-        appNamespace: envelope.appNamespace,
-        origin: envelope.origin,
-        createdAt: envelope.createdAt,
-        payload: envelope.payload
-    };
-    const checksum = hashString(stableStringify(checksumBase));
-    if (checksum !== envelope.checksum) errors.push('Hydration checksum mismatch');
-    return {
-        ok: 0 === errors.length,
-        errors
-    };
-}
-export { createHydrationEnvelope, createRequestEnvelope, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan };

package/dist/esm-node/runtime/effect/adapter/constants.mjs

@@ -1,7 +0,0 @@
-import "node:module";
-const before = [
-    'custom-server-hook',
-    'custom-server-middleware',
-    'render'
-];
-export { before };

package/dist/esm-node/runtime/effect/adapter/cross-project-policy.mjs

@@ -1,29 +0,0 @@
-import "node:module";
-import { logger } from "@modern-js/utils";
-import { HttpApi } from "effect/unstable/httpapi";
-import { resolveAdapterCrossProjectPolicy } from "../../../utils/crossProjectServerPolicy.mjs";
-import { collectEffectEndpoints, extractHttpApiFromModule, toOperationContractSources } from "../endpoint-contracts.mjs";
-function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
-    const contractSourcesPromise = null === mod ? Promise.resolve([]) : Promise.resolve().then(()=>extractHttpApiFromModule(mod, HttpApi.isHttpApi)).then((effectApi)=>{
-        if (null !== effectApi) {
-            const reflect = (apiValue, handlers)=>{
-                if (!HttpApi.isHttpApi(apiValue)) throw new Error('[BFF][Effect] Endpoint reflection received a non-HttpApi value.');
-                HttpApi.reflect(apiValue, {
-                    onGroup: handlers.onGroup ?? (()=>{}),
-                    onEndpoint: handlers.onEndpoint
-                });
-            };
-            return toOperationContractSources(collectEffectEndpoints(reflect, effectApi, prefix));
-        }
-        return [];
-    }).catch((error)=>{
-        logger.warn(`[BFF][Effect] Failed reflect HttpApi endpoints cross-project policy: ${String(error)}`);
-        return [];
-    });
-    return contractSourcesPromise.then((contractSources)=>{
-        const policy = resolveAdapterCrossProjectPolicy(api, contractSources);
-        if (policy?.enabled === true && 0 === contractSources.length) logger.warn('[BFF][Effect] Cross-project policy enabled but no HttpApi endpoints could be reflected; requests fail operation-contract matching unless allowUnknownOperations is enabled.');
-        return policy;
-    });
-}
-export { resolveEffectAdapterCrossProjectPolicy };

package/dist/esm-node/runtime/effect/adapter/entry.mjs

@@ -1,53 +0,0 @@
-import "node:module";
-import { API_DIR, findExists, fs, isProd } from "@modern-js/utils";
-import path from "path";
-const JS_OR_TS_EXTS = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.mjs',
-    '.mts',
-    '.cjs',
-    '.cts'
-];
-function resolveJsOrTsEntry(entryWithoutOrWithExt) {
-    const extension = path.extname(entryWithoutOrWithExt);
-    if (JS_OR_TS_EXTS.includes(extension)) return fs.existsSync(entryWithoutOrWithExt) ? entryWithoutOrWithExt : void 0;
-    return findExists(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutOrWithExt}${ext}`)) || void 0;
-}
-function builtEntryPath(entryPath) {
-    return entryPath.replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js');
-}
-function relativeAppPath(appDirectory, entryPath) {
-    const relativePath = path.relative(appDirectory, entryPath);
-    return '..' === relativePath || relativePath.startsWith(`..${path.sep}`) ? void 0 : relativePath;
-}
-function isDependencyPath(relativePath) {
-    return relativePath?.split(/[\\/]/u).includes('node_modules') ?? false;
-}
-function resolveEffectAdapterEntryFile(api) {
-    const { appDirectory, apiDirectory, distDirectory } = api.getServerContext();
-    const appRoot = path.resolve(appDirectory || process.cwd());
-    const productionRoot = isProd() && distDirectory ? path.resolve(distDirectory) : void 0;
-    const bffConfig = api.getServerConfig()?.bff;
-    const configuredEntry = bffConfig?.effect?.entry;
-    if (configuredEntry) {
-        const sourceEntry = path.isAbsolute(configuredEntry) ? configuredEntry : path.resolve(appRoot, configuredEntry);
-        if (productionRoot) {
-            const relativeEntry = relativeAppPath(appRoot, sourceEntry);
-            if (void 0 === relativeEntry || isDependencyPath(relativeEntry)) return resolveJsOrTsEntry(sourceEntry);
-            return relativeEntry ? resolveJsOrTsEntry(builtEntryPath(path.resolve(productionRoot, relativeEntry))) : void 0;
-        }
-        return resolveJsOrTsEntry(sourceEntry);
-    }
-    const resolvedApiDirectory = path.resolve(appRoot, apiDirectory || API_DIR);
-    const productionApiDirectory = productionRoot ? void 0 !== relativeAppPath(productionRoot, resolvedApiDirectory) ? resolvedApiDirectory : (()=>{
-        const relativeApiDirectory = relativeAppPath(appRoot, resolvedApiDirectory);
-        if (isDependencyPath(relativeApiDirectory)) return resolvedApiDirectory;
-        return relativeApiDirectory ? path.resolve(productionRoot, relativeApiDirectory) : void 0;
-    })() : resolvedApiDirectory;
-    if (!productionApiDirectory) return;
-    return resolveJsOrTsEntry(path.resolve(productionApiDirectory, 'index'));
-}
-export { resolveEffectAdapterEntryFile };

package/dist/esm-node/runtime/effect/adapter/error-response.mjs

@@ -1,44 +0,0 @@
-import "node:module";
-import { logger } from "@modern-js/utils";
-import { createSafeFailureResponse } from "../../safe-failure.mjs";
-function createEffectAdapterRuntimeErrorResponse(api, error, c) {
-    try {
-        const serverConfig = api.getServerConfig();
-        const onErrorHandler = serverConfig?.onError;
-        if (void 0 !== onErrorHandler) {
-            const onErrorContext = ensureJsonContext(c);
-            return Promise.resolve(onErrorHandler(error instanceof Error ? error : new Error(String(error)), onErrorContext)).then((result)=>result instanceof Response ? result : createSafeFailureResponse(error)).catch((configError)=>{
-                logger.error(`Error in serverConfig.onError handler: ${String(configError)}`);
-                return createSafeFailureResponse(error);
-            });
-        }
-        logger.error(error instanceof Error ? error : new Error(String(error)));
-    } catch (configError) {
-        logger.error(`Error in serverConfig.onError handler: ${configError}`);
-    }
-    return Promise.resolve(createSafeFailureResponse(error));
-}
-function ensureJsonContext(c) {
-    if ('json' in c && 'function' == typeof c.json) return c;
-    const headers = {
-        'content-type': 'application/json; charset=utf-8'
-    };
-    const withJson = Object.assign({}, c, {
-        json (data, statusOrInit = 200, extraHeaders) {
-            const responseInit = 'number' == typeof statusOrInit ? {
-                status: statusOrInit,
-                headers: extraHeaders
-            } : statusOrInit;
-            const responseHeaders = new Headers(headers);
-            if (void 0 !== responseInit.headers) new Headers(responseInit.headers).forEach((value, key)=>{
-                responseHeaders.set(key, value);
-            });
-            return new Response(JSON.stringify(data), {
-                ...responseInit,
-                headers: responseHeaders
-            });
-        }
-    });
-    return withJson;
-}
-export { createEffectAdapterRuntimeErrorResponse };

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

@@ -1,16 +0,0 @@
-import "node:module";
-import { logger } from "@modern-js/utils";
-import { checkCrossProjectPolicyForRequest } from "../../../utils/crossProjectServerPolicy.mjs";
-import { resolveEffectBffModuleHandler } from "../module.mjs";
-async function loadEffectAdapterHandlerFromModule(api, mod, crossProjectPolicy) {
-    const effectConfig = api.getServerConfig()?.bff?.effect;
-    return resolveEffectBffModuleHandler(mod, {
-        openapi: effectConfig?.openapi,
-        dataPlatform: effectConfig?.dataPlatform,
-        validateRequest: (request)=>checkCrossProjectPolicyForRequest(request, crossProjectPolicy),
-        onWarning: (message)=>{
-            logger.warn(message);
-        }
-    });
-}
-export { loadEffectAdapterHandlerFromModule };

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

@@ -1,108 +0,0 @@
-import "node:module";
-import { fs, isProd, logger } from "@modern-js/utils";
-import path from "path";
-import { loadEffectBuiltModule, loadEffectSourceModule } from "../../utils/effectSourceLoader.mjs";
-import { before } from "./adapter/constants.mjs";
-import { resolveEffectAdapterCrossProjectPolicy } from "./adapter/cross-project-policy.mjs";
-import { resolveEffectAdapterEntryFile } from "./adapter/entry.mjs";
-import { createEffectAdapterRuntimeErrorResponse } from "./adapter/error-response.mjs";
-import { loadEffectAdapterHandlerFromModule } from "./adapter/handler.mjs";
-import { runWithEffectContext } from "./context.mjs";
-import { dispatchEffectBffRequestWithContext } from "./dispatch.mjs";
-class EffectAdapter {
-    resolveEntryFile() {
-        return resolveEffectAdapterEntryFile(this.api);
-    }
-    async reloadHandler() {
-        if (!this.isEffect) return;
-        const entryFile = this.resolveEntryFile();
-        if (!entryFile) {
-            await this.disposeCurrentHandler();
-            this.handler = null;
-            return;
-        }
-        if (!await fs.pathExists(entryFile)) {
-            await this.disposeCurrentHandler();
-            this.handler = null;
-            return;
-        }
-        await this.disposeCurrentHandler();
-        let mod;
-        try {
-            const { appDirectory } = this.api.getServerContext();
-            mod = await (isProd() ? loadEffectBuiltModule(entryFile) : loadEffectSourceModule({
-                resourcePath: entryFile,
-                appDir: appDirectory || path.dirname(entryFile)
-            }));
-        } catch (error) {
-            logger.error(`[BFF][Effect] Failed to load Effect entry: ${entryFile}\n${String(error)}`);
-            this.handler = null;
-            return;
-        }
-        this.crossProjectPolicy = await resolveEffectAdapterCrossProjectPolicy(this.api, this.prefix, mod);
-        const loaded = await loadEffectAdapterHandlerFromModule(this.api, mod, this.crossProjectPolicy);
-        if (!loaded) {
-            logger.warn(`[BFF][Effect] Invalid Effect entry module: ${entryFile}. Export defineEffectBff(...) or a { api, layer } HttpApi module.`);
-            this.handler = null;
-            return;
-        }
-        this.handler = loaded.handler;
-        this.dispose = loaded.dispose || null;
-    }
-    async disposeCurrentHandler() {
-        if (!this.dispose) return;
-        try {
-            await this.dispose();
-        } catch (error) {
-            logger.warn(`[BFF][Effect] Failed dispose previous handler: ${String(error)}`);
-        } finally{
-            this.dispose = null;
-        }
-    }
-    constructor(api){
-        this.isEffect = true;
-        this.handler = null;
-        this.dispose = null;
-        this.prefix = '/api';
-        this.registerMiddleware = async (options)=>{
-            const { prefix, enableHandleWeb } = options;
-            const { bffRuntimeFramework, middlewares: globalMiddlewares } = this.api.getServerContext();
-            if ('hono' === bffRuntimeFramework) {
-                this.isEffect = false;
-                return;
-            }
-            this.prefix = prefix || this.prefix;
-            await this.reloadHandler();
-            this.effectMiddleware = {
-                name: 'effect-api-handler',
-                path: enableHandleWeb ? '*' : `${prefix}/*`,
-                method: 'all',
-                order: 'post',
-                before: before,
-                handler: async (c, next)=>{
-                    if (!this.handler) {
-                        if (enableHandleWeb) return void await next();
-                        return createEffectAdapterRuntimeErrorResponse(this.api, new Error('[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.'), c);
-                    }
-                    const response = await dispatchEffectBffRequestWithContext(this.handler, c.req.raw, {
-                        prefix,
-                        env: c.env,
-                        path: c.req.path,
-                        method: c.req.method,
-                        runWithEffectContext: runWithEffectContext,
-                        onError: (error)=>createEffectAdapterRuntimeErrorResponse(this.api, error, c)
-                    });
-                    if (404 === response.status && enableHandleWeb) return void await next();
-                    return new Response(response.body, response);
-                }
-            };
-            globalMiddlewares.push(this.effectMiddleware);
-        };
-        this.onApiHandlersUpdated = async ()=>{
-            if (!this.isEffect || isProd()) return;
-            await this.reloadHandler();
-        };
-        this.api = api;
-    }
-}
-export { EffectAdapter };

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

@@ -1,62 +0,0 @@
-import "node:module";
-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);
-    if (remote.entry.startsWith('http://') || remote.entry.startsWith('https://')) {
-        const response = await fetch(remote.entry);
-        if (!response.ok) throw new Error(`[BFF][Effect] Failed to load backend federation remote ${remote.name}: ${response.status}`);
-        return response.text();
-    }
-    throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} cannot load CommonJS entry ${remote.entry}.`);
-}
-function evaluateCommonJsEntry(remote, source) {
-    const module = {
-        exports: {}
-    };
-    const exports = module.exports;
-    const evaluate = new Function('module', 'exports', 'globalThis', source);
-    evaluate(module, exports, globalThis);
-    const entry = module.exports.default ?? module.exports;
-    if (!isRecord(entry)) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} entry must load object module.`);
-    return 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, plugins) {
-    const pluginEntry = await resolvePluginEntry(remote, 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 evaluateCommonJsEntry(remote, await readCommonJsEntrySource(remote));
-}
-async function loadBackendFederationExpose(remote, expose, options) {
-    const entry = await loadBackendFederationEntry(remote, options.plugins);
-    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 };

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

@@ -1,42 +0,0 @@
-import "node:module";
-import { isRecord } from "./utils.mjs";
-function validateExpectedBackendFederationIdentity(loaded, expected, options = {}) {
-    const allowMissing = true === options.allowMissingIdentityMetadata;
-    const issues = [];
-    const contract = isRecord(loaded) ? loaded.backendFederationContract : void 0;
-    const compatibility = isRecord(contract) ? contract.compatibility : void 0;
-    if (!isRecord(compatibility)) {
-        if (allowMissing) return [];
-        return [
-            {
-                path: 'backendFederationContract.compatibility',
-                message: 'loaded module declares no compatibility metadata; delivery-unit identity cannot be validated'
-            }
-        ];
-    }
-    const unitId = compatibility.unitId;
-    if ('string' != typeof unitId || 0 === unitId.length) {
-        if (!allowMissing) issues.push({
-            path: 'backendFederationContract.compatibility.unitId',
-            message: `missing delivery-unit id; expected ${expected.unitId}`
-        });
-    } else if (unitId !== expected.unitId) issues.push({
-        path: 'backendFederationContract.compatibility.unitId',
-        message: `expected ${expected.unitId}, received ${unitId}`
-    });
-    const build = compatibility.build;
-    if ('string' != typeof build || 0 === build.length) {
-        if (!allowMissing) issues.push({
-            path: 'backendFederationContract.compatibility.build',
-            message: `missing build marker; expected ${expected.buildMarker}`
-        });
-    } else if (build !== expected.buildMarker) issues.push({
-        path: 'backendFederationContract.compatibility.build',
-        message: `expected ${expected.buildMarker}, received ${build}`
-    });
-    return issues;
-}
-function formatBackendFederationIdentityIssues(issues) {
-    return issues.map((issue)=>`${issue.path}: ${issue.message}`).join('; ');
-}
-export { formatBackendFederationIdentityIssues, validateExpectedBackendFederationIdentity };