@bleedingdev/modern-js-plugin-bff-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/src/backend-federation-manifest/load.ts

@@ -25,6 +25,10 @@ import {
   validateLoadedBackendFederationContract,
 } from './validation';
 
+// One manifest+entry budget. Explicit outer 0 opts out; nested 0 cannot
+// disable a positive nested deadline.
+const DEFAULT_SHARED_MANIFEST_LOAD_TIMEOUT_MS = 10_000;
+
 function createManifestLoadScope(
   options: BackendFederationManifestAdapterOptions,
 ) {
@@ -44,9 +48,14 @@ function createManifestLoadScope(
       );
     }
   }
+  const positivePolicyTimeouts = policyTimeouts.filter(timeout => timeout > 0);
   const timeoutMs =
     options.timeoutMs ??
-    (policyTimeouts.length > 0 ? Math.min(...policyTimeouts) : 0);
+    (policyTimeouts.length === 0
+      ? DEFAULT_SHARED_MANIFEST_LOAD_TIMEOUT_MS
+      : positivePolicyTimeouts.length > 0
+        ? Math.min(...positivePolicyTimeouts)
+        : 0);
   const inputSignals = [
     options.signal,
     options.manifestPolicy?.signal,
@@ -140,6 +149,39 @@ function throwIfManifestLoadAborted(signal: AbortSignal) {
   }
 }
 
+// Stop waiting even when trusted plugin work ignores cancellation. The race
+// observes late rejections; it cannot stop that work from running.
+function settleOnSharedAbort<T>(
+  promise: Promise<T>,
+  signal: AbortSignal,
+): Promise<T> {
+  if (signal.aborted) {
+    // Observe work even when the pre-aborted path never reaches Promise.race.
+    promise.catch(() => {});
+    throwIfManifestLoadAborted(signal);
+  }
+
+  let onAbort: (() => void) | undefined;
+  const aborted = new Promise<never>((_resolve, reject) => {
+    onAbort = () => {
+      reject(
+        new BackendFederationManifestAdapterError(
+          'remote_unavailable',
+          '[BFF][Effect] Backend federation load was aborted before remote execution.',
+          signal.reason,
+        ),
+      );
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+  });
+
+  return Promise.race([promise, aborted]).finally(() => {
+    if (onAbort) {
+      signal.removeEventListener('abort', onAbort);
+    }
+  });
+}
+
 export async function loadBackendFederatedEffectApiFromManifest(
   options: BackendFederationManifestAdapterOptions,
 ): Promise<BackendFederatedEffectApiModule> {
@@ -150,16 +192,19 @@ export async function loadBackendFederatedEffectApiFromManifest(
   try {
     scope = createManifestLoadScope(options);
     throwIfManifestLoadAborted(scope.signal);
-    manifest = await loadBackendFederationManifest({
-      ...options,
-      manifestPolicy: {
-        ...options.manifestPolicy,
+    manifest = await settleOnSharedAbort(
+      loadBackendFederationManifest({
+        ...options,
+        manifestPolicy: {
+          ...options.manifestPolicy,
+          signal: scope.signal,
+          timeoutMs: 0,
+        },
         signal: scope.signal,
         timeoutMs: 0,
-      },
-      signal: scope.signal,
-      timeoutMs: 0,
-    });
+      }),
+      scope.signal,
+    );
     validateBackendFederationManifest(manifest, options.expected);
     remote = resolveBackendFederationRemoteFromManifest(
       manifest,
@@ -223,24 +268,28 @@ export async function loadBackendFederatedEffectApiFromManifest(
         'manifest_invalid',
         'Backend federation manifest requires delivery-unit identity.',
       );
-    const loaded = await loadBackendFederatedEffectApi({
-      hostName: options.hostName,
-      remote,
-      ...(options.plugins ? { plugins: options.plugins } : {}),
-      entryPolicy: {
-        ...options.entryPolicy,
-        signal: scope.signal,
-        timeoutMs: 0,
-      },
-      ...(options.runtime ? { runtime: options.runtime } : {}),
-      expected: { unitId, buildMarker },
-    }).catch((error: unknown) => {
-      throw new BackendFederationManifestAdapterError(
-        scope?.timedOut() === true ? 'timeout' : classifyLoadError(error),
-        `[BFF][Effect] Backend federation remote ${remote?.name ?? 'unknown'} could not load ${remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE}.`,
-        error,
-      );
-    });
+    const loaded = await settleOnSharedAbort(
+      loadBackendFederatedEffectApi({
+        hostName: options.hostName,
+        remote,
+        ...(options.plugins ? { plugins: options.plugins } : {}),
+        ...(options.shared ? { shared: options.shared } : {}),
+        entryPolicy: {
+          ...options.entryPolicy,
+          signal: scope.signal,
+          timeoutMs: 0,
+        },
+        ...(options.runtime ? { runtime: options.runtime } : {}),
+        expected: { unitId, buildMarker },
+      }).catch((error: unknown) => {
+        throw new BackendFederationManifestAdapterError(
+          scope?.timedOut() === true ? 'timeout' : classifyLoadError(error),
+          `[BFF][Effect] Backend federation remote ${remote?.name ?? 'unknown'} could not load ${remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE}.`,
+          error,
+        );
+      }),
+      scope.signal,
+    );
 
     validateLoadedBackendFederationContract(loaded, manifest, remote);
 

package/src/backend-federation-manifest/node.ts

@@ -1,14 +1,15 @@
 import { evaluateNodeBackendFederationCommonJs } from '@modern-js/server-runtime-extensions/backend-federation-security/node';
-
 import type { BackendFederatedEffectApiModule } from '../backend-federation';
+import { withEffectBffHostShared } from '../backend-federation/node-shared';
 import { loadBackendFederatedEffectApiFromManifest as loadUniversalBackendFederatedEffectApiFromManifest } from './load';
 import type { BackendFederationManifestAdapterOptions } from './types';
 
-export function loadBackendFederatedEffectApiFromManifest(
+export async function loadBackendFederatedEffectApiFromManifest(
   options: BackendFederationManifestAdapterOptions,
 ): Promise<BackendFederatedEffectApiModule> {
   return loadUniversalBackendFederatedEffectApiFromManifest({
     ...options,
+    shared: withEffectBffHostShared(options.shared),
     entryPolicy: {
       ...options.entryPolicy,
       evaluateCommonJs:

package/src/backend-federation-manifest/remote.ts

@@ -91,12 +91,6 @@ export function resolveBackendFederationRemoteFromManifest(
     entry: remoteEntryUrl,
     type: remoteType,
     ...(verification ? { verification } : {}),
-    ...(remoteOverride.entryGlobalName
-      ? { entryGlobalName: remoteOverride.entryGlobalName }
-      : {}),
     expose,
-    ...(remoteOverride.shareScope
-      ? { shareScope: remoteOverride.shareScope }
-      : {}),
   };
 }

package/src/backend-federation-manifest/types.ts

@@ -12,6 +12,7 @@ import type {
 import type {
   BackendFederatedEffectApiModule,
   BackendFederationRemote,
+  BackendFederationRuntimeOptions,
 } from '../backend-federation';
 import type { BackendFederationManifestAdapterError } from './errors';
 
@@ -68,6 +69,7 @@ export type BackendFederationManifestAdapterOptions = {
   plugins?: ModuleFederationRuntimePlugin[];
   remote?: Partial<BackendFederationRemote>;
   runtime?: ModuleFederation;
+  shared?: BackendFederationRuntimeOptions['shared'];
   signal?: AbortSignal;
   timeoutMs?: number;
 };

package/src/backend-federation-manifest/validation.ts

@@ -10,6 +10,11 @@ import {
   type BackendFederatedEffectApiModule,
   type BackendFederationRemote,
 } from '../backend-federation';
+import {
+  backendFederationCompatibility,
+  formatBackendFederationIdentityIssues,
+  validateBackendFederationCompatibility,
+} from '../backend-federation/identity';
 import {
   assertConsistentValue,
   assertManifestAdapter,
@@ -19,7 +24,6 @@ import {
 import {
   backendFederationMetadata,
   manifestDeliveryUnit,
-  recordField,
   stringValue,
   versionBoundaryMetadata,
 } from './metadata';
@@ -166,7 +170,7 @@ export function validateLoadedBackendFederationContract(
   const loadedContract = loaded.backendFederationContract;
   const backendFederation = backendFederationMetadata(manifest);
   const boundary = versionBoundaryMetadata(manifest);
-  const compatibility = recordField(loadedContract, 'compatibility');
+  const compatibility = backendFederationCompatibility(loaded);
 
   assertManifestAdapter(
     compatibility,
@@ -186,26 +190,6 @@ export function validateLoadedBackendFederationContract(
     remote.name,
     'expose name',
   );
-  assertVersionValue(
-    stringValue(compatibility.contractVersion),
-    stringValue(backendFederation?.contractVersion),
-    'expose contractVersion',
-  );
-  assertVersionValue(
-    stringValue(compatibility.nodeAdapterVersion),
-    stringValue(backendFederation?.nodeAdapterVersion),
-    'expose nodeAdapterVersion',
-  );
-  assertVersionValue(
-    stringValue(compatibility.packageName),
-    stringValue(boundary?.packageName),
-    'expose packageName',
-  );
-  assertVersionValue(
-    stringValue(compatibility.build),
-    stringValue(boundary?.buildVersion),
-    'expose buildVersion',
-  );
 
   const deliveryUnit = manifestDeliveryUnit(backendFederation, boundary);
   const manifestUnitId =
@@ -213,15 +197,24 @@ export function validateLoadedBackendFederationContract(
     stringValue(deliveryUnit.top?.unitId);
   const manifestBuildMarker = stringValue(deliveryUnit.boundary?.buildMarker);
 
-  assertVersionValue(
-    stringValue(compatibility.unitId),
-    manifestUnitId,
-    'deliveryUnit.unitId vs expose compatibility.unitId',
-  );
+  const issues = validateBackendFederationCompatibility(compatibility, {
+    contractVersion: stringValue(backendFederation?.contractVersion),
+    nodeAdapterVersion: stringValue(backendFederation?.nodeAdapterVersion),
+    packageName: stringValue(boundary?.packageName),
+    unitId: manifestUnitId,
+    build: manifestBuildMarker ?? stringValue(boundary?.buildVersion),
+  });
+  // Manifest validation establishes buildVersion/buildMarker consistency; the
+  // executed expose is still checked independently against that trusted record.
   assertVersionValue(
     stringValue(compatibility.build),
-    manifestBuildMarker,
-    'deliveryUnit.buildMarker vs expose compatibility.build',
+    stringValue(boundary?.buildVersion),
+    'expose buildVersion',
+  );
+  assertManifestAdapter(
+    issues.length === 0,
+    'version_mismatch',
+    `[BFF][Effect] ${formatBackendFederationIdentityIssues(issues)}.`,
   );
 }
 

package/src/cross-project-policy/node.ts

@@ -1,48 +1,17 @@
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
 import '@modern-js/server-runtime-extensions/server-config';
 import type { ServerPluginAPI } from '@modern-js/server-core';
 import {
-  deriveOperationVersion,
   type OperationContractSource,
   resolveCrossProjectPolicy,
+  resolveOperationProducer,
 } from '@modern-js/server-runtime-extensions/bff-policy/node';
 
 import type { ResolvedCrossProjectPolicy } from './evaluation';
 
-const readNearestPackageVersion = (
-  startDir: string | undefined,
-): string | undefined => {
-  if (!startDir) {
-    return undefined;
-  }
-
-  let current = path.resolve(startDir);
-  for (let depth = 0; depth < 10; depth += 1) {
-    try {
-      const packageJson = JSON.parse(
-        readFileSync(path.join(current, 'package.json'), 'utf8'),
-      ) as { version?: unknown };
-      if (typeof packageJson.version === 'string') {
-        return packageJson.version;
-      }
-    } catch {
-      // The producer package may be nested below its package.json.
-    }
-
-    const parent = path.dirname(current);
-    if (parent === current) {
-      return undefined;
-    }
-    current = parent;
-  }
-
-  return undefined;
-};
-
 export const resolveAdapterCrossProjectPolicy = (
   api: ServerPluginAPI,
   handlers: OperationContractSource[],
+  producer?: ReturnType<typeof resolveOperationProducer>,
 ): ResolvedCrossProjectPolicy | undefined => {
   const bff = api.getServerConfig()?.bff;
   const { apiDirectory, appDirectory } = api.getServerContext() as {
@@ -53,11 +22,11 @@ export const resolveAdapterCrossProjectPolicy = (
   return resolveCrossProjectPolicy({
     crossProjectPolicy: bff?.crossProjectPolicy,
     handlers,
-    requestId: bff?.requestId,
     isCrossProjectServer: bff?.isCrossProjectServer,
-    operationVersion: deriveOperationVersion(
-      readNearestPackageVersion(apiDirectory) ??
-        readNearestPackageVersion(appDirectory),
-    ),
+    ...(producer ??
+      resolveOperationProducer({
+        directories: [apiDirectory, appDirectory],
+        requestId: bff?.requestId || 'default',
+      })),
   });
 };

package/src/{effect-adapter → effect-server}/cross-project-policy.ts

@@ -6,16 +6,18 @@ import {
   toOperationContractSources,
 } from '@modern-js/bff-effect/effect';
 import type { ServerPluginAPI } from '@modern-js/server-core';
+import type { resolveOperationProducer } from '@modern-js/server-runtime-extensions/bff-policy/node';
 import { logger } from '@modern-js/utils';
-import { HttpApi } from 'effect/unstable/httpapi';
+import { HttpApi } from 'effect/http-api';
 
 import { resolveAdapterCrossProjectPolicy } from '../cross-project-policy';
 import type { ResolvedCrossProjectPolicy } from '../cross-project-policy/evaluation';
 
-export function resolveEffectAdapterCrossProjectPolicy(
+export function resolveEffectServerCrossProjectPolicy(
   api: ServerPluginAPI,
   prefix: string,
   mod: EffectApiModule | null,
+  producer?: ReturnType<typeof resolveOperationProducer>,
 ): Promise<ResolvedCrossProjectPolicy | undefined> {
   const contractSourcesPromise =
     mod === null
@@ -52,7 +54,11 @@ export function resolveEffectAdapterCrossProjectPolicy(
           });
 
   return contractSourcesPromise.then(contractSources => {
-    const policy = resolveAdapterCrossProjectPolicy(api, contractSources);
+    const policy = resolveAdapterCrossProjectPolicy(
+      api,
+      contractSources,
+      producer,
+    );
     if (policy?.enabled === true && contractSources.length === 0) {
       logger.warn(
         '[BFF][Effect] Cross-project policy enabled but no HttpApi endpoints could be reflected; requests fail operation-contract matching unless allowUnknownOperations is enabled.',

package/src/effect-server/entry.ts

@@ -0,0 +1,18 @@
+// @effect-diagnostics nodeBuiltinImport:off strictBooleanExpressions:off
+import path from 'node:path';
+import '@modern-js/server-runtime-extensions/server-config';
+import type { ServerPluginAPI } from '@modern-js/server-core';
+import { API_DIR, isProd } from '@modern-js/utils';
+import { resolveEffectEntry } from '../effect-source-loader/paths';
+
+export function resolveEffectServerEntryFile(api: ServerPluginAPI) {
+  const { appDirectory, apiDirectory, distDirectory } = api.getServerContext();
+  const appDir = path.resolve(appDirectory || process.cwd());
+  return resolveEffectEntry({
+    appDir,
+    apiDir: path.resolve(appDir, apiDirectory || API_DIR),
+    effectEntry: api.getServerConfig()?.bff?.effect?.entry,
+    distDir:
+      isProd() && distDirectory ? path.resolve(distDirectory) : undefined,
+  }).path;
+}

package/src/{effect-adapter → effect-server}/error-response.ts

@@ -2,7 +2,7 @@ import { createSafeFailureResponse } from '@modern-js/runtime-extensions/safe-fa
 import type { Context, ServerPluginAPI } from '@modern-js/server-core';
 import { logger } from '@modern-js/utils';
 
-export function createEffectAdapterRuntimeErrorResponse(
+export function createEffectServerRuntimeErrorResponse(
   api: ServerPluginAPI,
   error: unknown,
   context: Context,

package/src/effect-server/index.ts

@@ -0,0 +1,243 @@
+// @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off nodeBuiltinImport:off strictBooleanExpressions:off
+
+import path from 'node:path';
+import '@modern-js/server-runtime-extensions/server-config';
+import {
+  dispatchEffectBffRequest,
+  type EffectApiModule,
+  type EffectBffRequestHandler,
+  resolveEffectBffModuleHandler,
+  useEffectContext,
+} from '@modern-js/bff-effect/effect';
+import type {
+  Context,
+  Next,
+  ServerPlugin,
+  ServerPluginAPI,
+} from '@modern-js/server-core';
+import { resolveOperationProducer } from '@modern-js/server-runtime-extensions/bff-policy/node';
+import {
+  createDisposableServerRuntimeHandle,
+  type DisposableServerRuntimeHandle,
+  registerServerRuntimeDisposer,
+} from '@modern-js/server-runtime-extensions/runtime-lifecycle';
+import { fs, isProd, logger } from '@modern-js/utils';
+
+import { checkCrossProjectPolicyForRequest } from '../cross-project-policy/evaluation';
+import {
+  loadEffectBuiltModule,
+  loadEffectSourceModule,
+} from '../effect-source-loader/loader';
+import { resolveEffectServerCrossProjectPolicy } from './cross-project-policy';
+import { resolveEffectServerEntryFile } from './entry';
+import { createEffectServerRuntimeErrorResponse } from './error-response';
+
+const EFFECT_MIDDLEWARE_BEFORE = [
+  'custom-server-hook',
+  'custom-server-middleware',
+  'render',
+];
+
+export default (): ServerPlugin => ({
+  name: '@modern-js/plugin-bff-extensions/effect-server',
+  setup(api: ServerPluginAPI) {
+    const runtimeFramework = api.getServerContext().bffRuntimeFramework;
+    if (runtimeFramework !== 'effect') {
+      throw new Error(
+        `Effect BFF server plugin requires Effect; received "${runtimeFramework}".`,
+      );
+    }
+    let handler: DisposableServerRuntimeHandle | null = null;
+    let unregisterRuntimeDisposer: (() => void) | undefined;
+    let prefix = '/api';
+    let prefixes = ['/api'];
+    let matchingPrefixes = ['/api'];
+    let retired = false;
+
+    const dispose = async () => {
+      retired = true;
+      unregisterRuntimeDisposer?.();
+      unregisterRuntimeDisposer = undefined;
+      const previous = handler;
+      handler = null;
+      await previous?.dispose();
+    };
+
+    const loadHandler = async () => {
+      const entryFile = resolveEffectServerEntryFile(api);
+      if (!entryFile || !(await fs.pathExists(entryFile))) {
+        handler = null;
+        return;
+      }
+
+      const { appDirectory } = api.getServerContext();
+      let mod: EffectApiModule;
+      try {
+        mod = (await (isProd()
+          ? loadEffectBuiltModule(entryFile)
+          : loadEffectSourceModule({
+              resourcePath: entryFile,
+              appDir: appDirectory || path.dirname(entryFile),
+              globalVars: api.getServerConfig()?.source?.globalVars,
+            }))) as EffectApiModule;
+      } catch (error) {
+        logger.error(
+          `[BFF][Effect] Failed to load Effect entry: ${entryFile}\n${String(error)}`,
+        );
+        throw error;
+      }
+
+      const producer = resolveOperationProducer({
+        directories: [path.dirname(entryFile), appDirectory],
+        requestId: api.getServerConfig()?.bff?.requestId,
+      });
+      const crossProjectPolicies = new Map(
+        await Promise.all(
+          prefixes.map(
+            async prefix =>
+              [
+                prefix,
+                await resolveEffectServerCrossProjectPolicy(
+                  api,
+                  prefix,
+                  mod,
+                  producer,
+                ),
+              ] as const,
+          ),
+        ),
+      );
+      const effectConfig = api.getServerConfig()?.bff?.effect;
+      const loaded = await resolveEffectBffModuleHandler(mod, {
+        openapi: effectConfig?.openapi,
+        dataPlatform: effectConfig?.dataPlatform,
+        validateRequest: request => {
+          const { path: mountedPathname } = useEffectContext();
+          const prefix = 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 checkCrossProjectPolicyForRequest(
+            new Request(requestUrl, request),
+            crossProjectPolicies.get(prefix),
+          );
+        },
+        onWarning: message => logger.warn(message),
+      });
+      if (!loaded) {
+        const error = new Error(
+          `[BFF][Effect] Invalid Effect entry module: ${entryFile}. Export defineEffectBff(...) or a { api, layer } HttpApi module.`,
+        );
+        logger.warn(error.message);
+        throw error;
+      }
+      const candidateOwner = {};
+      if (loaded.dispose)
+        registerServerRuntimeDisposer(candidateOwner, loaded.dispose);
+      const candidate = createDisposableServerRuntimeHandle(
+        candidateOwner,
+        loaded.handler,
+      );
+      if (retired) {
+        await candidate.dispose();
+        throw new Error('Cannot initialize a retired Effect server.');
+      }
+      handler = candidate;
+    };
+
+    api.onPrepare(async () => {
+      const { middlewares: globalMiddlewares } = api.getServerContext();
+      const configuredPrefix = api.getServerConfig()?.bff?.prefix;
+      const enableHandleWeb = api.getServerConfig()?.bff?.enableHandleWeb;
+      const configuredPrefixes = Array.isArray(configuredPrefix)
+        ? configuredPrefix.filter(Boolean)
+        : [configuredPrefix || '/api'];
+      prefixes = [
+        ...new Set(
+          configuredPrefixes.length > 0 ? configuredPrefixes : ['/api'],
+        ),
+      ];
+      matchingPrefixes = [...prefixes].sort(
+        (left, right) => right.length - left.length,
+      );
+      prefix = prefixes[0] || '/api';
+      const { serverBase } = api.getServerContext() as { serverBase?: object };
+      if (serverBase)
+        unregisterRuntimeDisposer = registerServerRuntimeDisposer(
+          serverBase,
+          dispose,
+        );
+      try {
+        await loadHandler();
+      } catch (error) {
+        await dispose();
+        throw error;
+      }
+
+      const middlewarePrefixes = enableHandleWeb ? [prefix] : matchingPrefixes;
+      const middlewares = middlewarePrefixes.map(middlewarePrefix => ({
+        name: 'effect-api-handler',
+        path: enableHandleWeb ? '*' : `${middlewarePrefix}/*`,
+        method: 'all' as const,
+        order: 'post' as const,
+        before: EFFECT_MIDDLEWARE_BEFORE,
+        handler: async (context: Context, next: Next) => {
+          const activeHandler = handler;
+          if (!activeHandler) {
+            if (enableHandleWeb) {
+              await next();
+              return;
+            }
+            return createEffectServerRuntimeErrorResponse(
+              api,
+              new Error(
+                '[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.',
+              ),
+              context,
+            );
+          }
+
+          const mountedPrefix = enableHandleWeb
+            ? matchingPrefixes.find(
+                item =>
+                  item === '/' ||
+                  context.req.path === item ||
+                  context.req.path.startsWith(`${item}/`),
+              ) || prefix
+            : middlewarePrefix;
+          const response = await dispatchEffectBffRequest(
+            activeHandler as EffectBffRequestHandler,
+            context.req.raw,
+            {
+              prefix: mountedPrefix,
+              env: context.env as Record<string, unknown>,
+              path: context.req.path,
+              method: context.req.method,
+              onError: error =>
+                createEffectServerRuntimeErrorResponse(api, error, context),
+            },
+          );
+
+          if (response.status === 404 && enableHandleWeb) {
+            await next();
+            return;
+          }
+
+          return new Response(response.body, response);
+        },
+      }));
+
+      globalMiddlewares.push(...middlewares);
+    });
+  },
+});