@bleedingdev/modern-js-plugin-bff-extensions 3.9.0-ultramodern.5 → 3.9.0-ultramodern.7

package/src/backend-federation/validate-loaded.ts

@@ -9,8 +9,7 @@ import { isRecord } from './utils';
 export function validateLoadedBackendFederatedEffectApi(
   loaded: unknown,
   options: {
-    allowMissingIdentityMetadata?: boolean;
-    expected?: BackendFederationExpectedIdentity;
+    expected: BackendFederationExpectedIdentity;
     remoteName: string;
     remoteRequest: string;
   },
@@ -52,14 +51,10 @@ export function validateLoadedBackendFederatedEffectApi(
     );
   }
 
-  if (options.expected !== undefined) {
+  {
     const issues = validateExpectedBackendFederationIdentity(
       loaded,
       options.expected,
-      {
-        allowMissingIdentityMetadata:
-          options.allowMissingIdentityMetadata === true,
-      },
     );
     if (issues.length > 0) {
       throw new Error(

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

@@ -7,6 +7,12 @@ import {
 } from '../backend-federation';
 import { loadBackendFederatedEffectApi } from '../backend-federation/load';
 import { BackendFederationManifestAdapterError } from './errors';
+import {
+  backendFederationMetadata,
+  manifestDeliveryUnit,
+  stringValue,
+  versionBoundaryMetadata,
+} from './metadata';
 import { loadBackendFederationManifest } from './reference';
 import { resolveBackendFederationRemoteFromManifest } from './remote';
 import type {
@@ -204,6 +210,19 @@ export async function loadBackendFederatedEffectApiFromManifest(
       );
     }
 
+    const deliveryUnit = manifestDeliveryUnit(
+      backendFederationMetadata(manifest),
+      versionBoundaryMetadata(manifest),
+    );
+    const unitId =
+      stringValue(deliveryUnit.boundary?.unitId) ??
+      stringValue(deliveryUnit.top?.unitId);
+    const buildMarker = stringValue(deliveryUnit.boundary?.buildMarker);
+    if (!unitId || !buildMarker)
+      throw new BackendFederationManifestAdapterError(
+        'manifest_invalid',
+        'Backend federation manifest requires delivery-unit identity.',
+      );
     const loaded = await loadBackendFederatedEffectApi({
       hostName: options.hostName,
       remote,
@@ -214,20 +233,7 @@ export async function loadBackendFederatedEffectApiFromManifest(
         timeoutMs: 0,
       },
       ...(options.runtime ? { runtime: options.runtime } : {}),
-      // MV-G23: route the manifest adapter through the raw loader's shared
-      // delivery-unit identity validation when an identity is expected.
-      ...(options.expected?.unitId && options.expected.buildMarker
-        ? {
-            expected: {
-              unitId: options.expected.unitId,
-              buildMarker: options.expected.buildMarker,
-            },
-            // The manifest's identity is already validated against
-            // `expected`; legacy exposes without identity metadata stay
-            // loadable (mismatching declared values still fail).
-            allowMissingIdentityMetadata: true,
-          }
-        : {}),
+      expected: { unitId, buildMarker },
     }).catch((error: unknown) => {
       throw new BackendFederationManifestAdapterError(
         scope?.timedOut() === true ? 'timeout' : classifyLoadError(error),

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

@@ -56,12 +56,6 @@ export function deliveryUnitMetadata(
   return recordField(record, 'deliveryUnit');
 }
 
-/**
- * Resolves the delivery-unit identity root for a manifest (ADR-0019 §3):
- * prefers `versionBoundary.deliveryUnit`, falls back to the top-level
- * `backendFederation.deliveryUnit` record. Both are additive/optional so
- * legacy manifests without delivery-unit metadata continue to validate.
- */
 export function manifestDeliveryUnit(
   backendFederation: Record<string, unknown> | undefined,
   boundary: Record<string, unknown> | undefined,

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

@@ -48,11 +48,6 @@ function resolveExpectedBuildMarker(
     );
   }
 
-  // Intentionally no fallback to `buildVersion` here: this is only used to
-  // compare against manifest `deliveryUnit.buildMarker`, which is a
-  // separate, additive field. Callers that only pass `buildVersion` (the
-  // pre-ADR-0019 expectation shape) must not be forced to also match a
-  // delivery-unit build marker on the manifest.
   return expected.buildMarker;
 }
 
@@ -70,7 +65,6 @@ export function validateBackendFederationManifest(
   const manifestShape = validateBackendFederationManifestContract(manifest, {
     expectedContractVersion: false,
     expectedNodeAdapterVersion: false,
-    validateDeliveryUnit: false,
   });
   assertManifestAdapter(
     manifestShape.ok,
@@ -151,6 +145,11 @@ export function validateBackendFederationManifest(
   const manifestUnitId =
     stringValue(deliveryUnit.boundary?.unitId) ??
     stringValue(deliveryUnit.top?.unitId);
+  assertManifestAdapter(
+    manifestUnitId && stringValue(deliveryUnit.boundary?.buildMarker),
+    'manifest_invalid',
+    'Backend federation manifest requires delivery-unit unitId and buildMarker.',
+  );
   assertVersionValue(manifestUnitId, expected.unitId, 'deliveryUnit.unitId');
   assertVersionValue(
     stringValue(deliveryUnit.boundary?.buildMarker),
@@ -214,16 +213,14 @@ export function validateLoadedBackendFederationContract(
     stringValue(deliveryUnit.top?.unitId);
   const manifestBuildMarker = stringValue(deliveryUnit.boundary?.buildMarker);
 
-  // Only enforced when both sides declare the field: absence on either side
-  // is a legacy manifest/expose and must stay backward compatible.
-  assertConsistentValue(
-    manifestUnitId,
+  assertVersionValue(
     stringValue(compatibility.unitId),
+    manifestUnitId,
     'deliveryUnit.unitId vs expose compatibility.unitId',
   );
-  assertConsistentValue(
-    manifestBuildMarker,
+  assertVersionValue(
     stringValue(compatibility.build),
+    manifestBuildMarker,
     'deliveryUnit.buildMarker vs expose compatibility.build',
   );
 }

package/src/{client-generator → effect-source-loader}/built-entry.ts

@@ -41,9 +41,7 @@ export async function bundleBuiltEffectEntryForNode(options: {
       }`,
     );
   }
-  const { bundleEffectEntryForNode } = await import(
-    '../effect-source-loader/loader'
-  );
+  const { bundleEffectEntryForNode } = await import('./loader');
   return bundleEffectEntryForNode({
     appDir,
     entryPath: builtEntry,

package/src/effect-source-loader/http-api-runtime.ts

@@ -0,0 +1,39 @@
+import {
+  extractHttpApiFromModule,
+  type HttpApiLike,
+  type HttpApiReflect,
+} from '@modern-js/bff-effect/effect';
+import { HttpApi } from 'effect/unstable/httpapi';
+import { loadEffectSourceModule } from './loader';
+
+type HttpApiRuntime = {
+  isHttpApi: (value: unknown) => boolean;
+  reflect: HttpApiReflect;
+};
+
+export function getHttpApiRuntime(): Promise<HttpApiRuntime> {
+  return Promise.resolve({
+    isHttpApi: HttpApi.isHttpApi,
+    reflect: (api, handlers) => {
+      if (!HttpApi.isHttpApi(api)) {
+        throw new TypeError('[BFF][Effect] Expected an HttpApi contract.');
+      }
+      HttpApi.reflect(api, {
+        onGroup: handlers.onGroup ?? (() => {}),
+        onEndpoint: handlers.onEndpoint,
+      });
+    },
+  });
+}
+
+export function loadEffectApi(options: {
+  appDir: string;
+  resourcePath: string;
+  onDependency?: (dependency: string) => void;
+}): Promise<HttpApiLike | null> {
+  return getHttpApiRuntime().then(httpApiRuntime =>
+    loadEffectSourceModule(options).then(mod =>
+      extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi),
+    ),
+  );
+}

package/src/effect-source-loader/index.ts

@@ -1,7 +1,9 @@
-export { resolveEffectEntryFile } from '../client-generator/paths';
+export {
+  bundleBuiltEffectEntryForNode,
+  resolveEffectEntryPaths,
+} from './built-entry';
 export { bundleEffectEntryForNode } from './loader';
+export { resolveEffectOperationContracts } from './operation-contracts';
+export { resolveEffectEntryFile } from './paths';
 export { bundleEffectWorkerRuntimeSource } from './worker-runtime-source';
-export {
-  generateEffectClientCode,
-  generateEffectWorkerRuntimeWrapper,
-} from './worker-runtime-wrapper';
+export { generateEffectWorkerRuntimeWrapper } from './worker-runtime-wrapper';

package/src/effect-source-loader/operation-contracts.ts

@@ -0,0 +1,72 @@
+import {
+  collectEffectEndpoints,
+  toOperationContractSources,
+} from '@modern-js/bff-effect/effect';
+import {
+  buildOperationContractMap,
+  deriveOperationVersion,
+} from '@modern-js/server-runtime-extensions/bff-policy/node';
+import { fs, upath as path } from '@modern-js/utils';
+import { getHttpApiRuntime, loadEffectApi } from './http-api-runtime';
+
+function getPackageInfo(
+  resourcePath: string,
+  appDir: string,
+  onDependency?: (dependency: string) => void,
+): { name?: string; version?: string } {
+  for (const startDir of [path.dirname(resourcePath), appDir]) {
+    let current = path.resolve(startDir);
+    for (let depth = 0; depth < 32; depth += 1) {
+      const packageJsonPath = path.join(current, 'package.json');
+      if (fs.existsSync(packageJsonPath)) {
+        onDependency?.(packageJsonPath);
+        try {
+          const packageJson = fs.readJSONSync(packageJsonPath) as {
+            name?: string;
+            version?: string;
+          };
+          return { name: packageJson.name, version: packageJson.version };
+        } catch {
+          return {};
+        }
+      }
+      const parent = path.dirname(current);
+      if (parent === current) {
+        break;
+      }
+      current = parent;
+    }
+  }
+  return {};
+}
+
+/** Derives server policy metadata without emitting or typing a client. */
+export async function resolveEffectOperationContracts(options: {
+  appDir: string;
+  resourcePath: string;
+  prefix: string;
+  requestId?: string;
+  onDependency?: (dependency: string) => void;
+}) {
+  const api = await loadEffectApi(options);
+  if (api === null) {
+    return null;
+  }
+  const runtime = await getHttpApiRuntime();
+  const endpoints = collectEffectEndpoints(
+    runtime.reflect,
+    api,
+    options.prefix,
+  );
+  const packageInfo = getPackageInfo(
+    options.resourcePath,
+    options.appDir,
+    options.onDependency,
+  );
+  const requestId = options.requestId?.trim() || packageInfo.name || 'default';
+  return buildOperationContractMap({
+    handlers: toOperationContractSources(endpoints),
+    requestId,
+    operationVersion: deriveOperationVersion(packageInfo.version),
+  });
+}

package/src/effect-source-loader/rspack-loader.ts

@@ -1,10 +1,8 @@
 import { realpathSync } from 'node:fs';
 import path from 'node:path';
-import type { HttpMethodDecider } from '@modern-js/types';
 import type { Rspack } from '@rsbuild/core';
 import {
   bundleEffectWorkerRuntimeSource,
-  generateEffectClientCode,
   generateEffectWorkerRuntimeWrapper,
   resolveEffectEntryFile,
 } from './index';
@@ -14,20 +12,7 @@ export interface EffectBffLoaderOptions {
   appDir: string;
   apiDir: string;
   effectEntry: string;
-  port: number;
-  target: string;
-  requestCreator?: string;
   requestId?: string;
-  httpMethodDecider?: HttpMethodDecider;
-  effectDataPlatformBatch?: {
-    enabled?: boolean;
-    endpoint?: string;
-    flushIntervalMs?: number;
-    maxBatchSize?: number;
-    maxBatchBytes?: number;
-    requestTimeoutMs?: number;
-    allowedMethods?: string[];
-  };
 }
 
 export default async function loader(
@@ -77,24 +62,9 @@ export default async function loader(
         ),
       );
     } else {
-      const code = await generateEffectClientCode({
-        appDir: options.appDir,
-        apiDir: options.apiDir,
-        resourcePath: this.resourcePath,
-        prefix: options.prefix,
-        port: Number(options.port),
-        target: options.target,
-        requestId: options.requestId,
-        requestCreator: options.requestCreator,
-        httpMethodDecider: options.httpMethodDecider,
-        dataPlatformBatch: options.effectDataPlatformBatch,
-        onDependency: dependency => this.addDependency(dependency),
-      });
-      if (code === null)
-        throw new Error(
-          `Failed to generate Effect client for ${this.resourcePath}`,
-        );
-      callback(undefined, code);
+      throw new Error(
+        'Effect BFF entries are server-only. Import the shared HttpApi contract and use HttpApiClient.make (or makeEffectHttpApiClient) for a fully inferred client.',
+      );
     }
   } catch (error) {
     callback(error instanceof Error ? error : new Error(String(error)));

package/src/effect-source-loader/worker-runtime-wrapper.ts

@@ -1,62 +1,20 @@
-// @effect-diagnostics asyncFunction:off strictBooleanExpressions:off
-import type { HttpMethodDecider } from '@modern-js/types';
-import type { EffectClientCodegenOptions } from '../client-generator/types';
-
-type EffectWorkerRuntimeGenerationOptions = {
-  apiDir: string;
-  appDir: string;
-  effectDataPlatformBatch?: {
-    allowedMethods?: string[];
-    enabled?: boolean;
-    endpoint?: string;
-    flushIntervalMs?: number;
-    maxBatchBytes?: number;
-    maxBatchSize?: number;
-    requestTimeoutMs?: number;
-  };
-  httpMethodDecider?: HttpMethodDecider;
-  port: number;
-  prefix: string;
-  requestCreator?: string;
-  requestId?: string;
-};
+import { resolveEffectOperationContracts } from './operation-contracts';
 
 export async function generateEffectWorkerRuntimeWrapper(
   loader: { addDependency: (dependency: string) => void },
-  options: EffectWorkerRuntimeGenerationOptions,
+  options: { appDir: string; prefix: string; requestId?: string },
   resourcePath: string,
 ) {
-  const { generateEffectClient } = await import(
-    '../client-generator/generator'
-  );
-  const artifacts = await generateEffectClient({
+  const operationContracts = await resolveEffectOperationContracts({
     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 { createEffectBffEdgeDispatcherFactory } from '@modern-js/bff-effect/effect-edge';
-export const __modern_create_effect_bff_dispatcher = createEffectBffEdgeDispatcherFactory(effectBffModule, ${JSON.stringify(operationContracts)});
+export const __modern_create_effect_bff_dispatcher = createEffectBffEdgeDispatcherFactory(effectBffModule, ${JSON.stringify(operationContracts ?? {})});
 `;
 }
-
-export async function generateEffectClientCode(
-  options: EffectClientCodegenOptions,
-) {
-  const { generateEffectClient } = await import(
-    '../client-generator/generator'
-  );
-  const artifacts = await generateEffectClient(options);
-  return artifacts === null ? null : artifacts.code;
-}

package/dist/cjs/backend-federation/legacy-warning.js

@@ -1,40 +0,0 @@
-"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__);
-const LEGACY_LOAD_WARNING = '[BFF][Effect] loadBackendFederatedEffectApi was called without an expected delivery-unit identity (expected.unitId + expected.buildMarker). Identity-less public backend loads are deprecated (ADR-0019/MV-G23) and will be rejected in a future major.';
-__webpack_require__.d(__webpack_exports__, {}, {
-    LEGACY_LOAD_WARNING: LEGACY_LOAD_WARNING
-});
-exports.LEGACY_LOAD_WARNING = __webpack_exports__.LEGACY_LOAD_WARNING;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "LEGACY_LOAD_WARNING"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

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

@@ -1,73 +0,0 @@
-"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__, {
-    generateEffectClient: ()=>generateEffectClient,
-    generateEffectClientCode: ()=>generateEffectClientCode
-});
-const effect_namespaceObject = require("@modern-js/bff-effect/effect");
-const utils_namespaceObject = require("@modern-js/utils");
-const external_rendering_js_namespaceObject = require("./rendering.js");
-const external_runtime_js_namespaceObject = require("./runtime.js");
-function generateEffectClient(options) {
-    return (0, external_runtime_js_namespaceObject.loadEffectApi)({
-        appDir: options.appDir,
-        resourcePath: options.resourcePath,
-        onDependency: options.onDependency
-    }).then((api)=>{
-        if (null === api) {
-            utils_namespaceObject.logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
-            return null;
-        }
-        return (0, external_runtime_js_namespaceObject.getHttpApiRuntime)().then((httpApiRuntime)=>{
-            const endpoints = (0, effect_namespaceObject.collectEffectEndpoints)(httpApiRuntime.reflect, api, options.prefix);
-            const generation = (0, external_rendering_js_namespaceObject.createEffectClientGeneration)(endpoints, options);
-            return {
-                code: (0, external_rendering_js_namespaceObject.renderEffectClientCode)(generation),
-                declaration: (0, external_rendering_js_namespaceObject.renderEffectClientDeclaration)(endpoints),
-                endpoints,
-                operationContracts: generation.operationContracts,
-                operationVersion: generation.operationVersion,
-                requestId: generation.requestId
-            };
-        });
-    });
-}
-function generateEffectClientCode(options) {
-    return generateEffectClient(options).then((artifacts)=>null === artifacts ? null : artifacts.code);
-}
-exports.generateEffectClient = __webpack_exports__.generateEffectClient;
-exports.generateEffectClientCode = __webpack_exports__.generateEffectClientCode;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "generateEffectClient",
-    "generateEffectClientCode"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/client-generator/index.js

@@ -1,54 +0,0 @@
-"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__, {
-    bundleBuiltEffectEntryForNode: ()=>external_built_entry_js_namespaceObject.bundleBuiltEffectEntryForNode,
-    generateEffectClient: ()=>external_generator_js_namespaceObject.generateEffectClient,
-    generateEffectClientCode: ()=>external_generator_js_namespaceObject.generateEffectClientCode,
-    resolveEffectEntryFile: ()=>external_paths_js_namespaceObject.resolveEffectEntryFile,
-    resolveEffectEntryPaths: ()=>external_built_entry_js_namespaceObject.resolveEffectEntryPaths
-});
-const external_built_entry_js_namespaceObject = require("./built-entry.js");
-const external_generator_js_namespaceObject = require("./generator.js");
-const external_paths_js_namespaceObject = require("./paths.js");
-exports.bundleBuiltEffectEntryForNode = __webpack_exports__.bundleBuiltEffectEntryForNode;
-exports.generateEffectClient = __webpack_exports__.generateEffectClient;
-exports.generateEffectClientCode = __webpack_exports__.generateEffectClientCode;
-exports.resolveEffectEntryFile = __webpack_exports__.resolveEffectEntryFile;
-exports.resolveEffectEntryPaths = __webpack_exports__.resolveEffectEntryPaths;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "bundleBuiltEffectEntryForNode",
-    "generateEffectClient",
-    "generateEffectClientCode",
-    "resolveEffectEntryFile",
-    "resolveEffectEntryPaths"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});