@bleedingdev/modern-js-plugin-bff-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/src/backend-federation/entry.ts

@@ -1,125 +0,0 @@
-// @effect-diagnostics asyncFunction:off globalFetch:off strictBooleanExpressions:off
-
-import {
-  evaluateBackendFederationCommonJsEntry,
-  loadVerifiedBackendFederationEntry,
-} from '@modern-js/server-runtime-extensions/backend-federation-security';
-import type { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
-
-import type {
-  BackendFederationEntryExports,
-  BackendFederationLoadEntryPlugin,
-  BackendFederationRemote,
-  BackendFederationRuntimeOptions,
-} from './types';
-import { isRecord, normalizeExpose } from './utils';
-
-function decodeDataUrl(url: string) {
-  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: BackendFederationRemote) {
-  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: BackendFederationRemote) {
-  const entry = await import(/* webpackIgnore: true */ remote.entry);
-  return (entry.default ?? entry) as BackendFederationEntryExports;
-}
-
-async function resolvePluginEntry(
-  remote: BackendFederationRemote,
-  plugins: ModuleFederationRuntimePlugin[] | undefined,
-) {
-  for (const plugin of plugins ?? []) {
-    const loadEntry = (plugin as BackendFederationLoadEntryPlugin).loadEntry;
-    if (typeof loadEntry !== 'function') {
-      continue;
-    }
-    const entry = await loadEntry({ remoteInfo: remote });
-    if (entry) {
-      return entry;
-    }
-  }
-}
-
-async function loadBackendFederationEntry(
-  remote: BackendFederationRemote,
-  options: BackendFederationRuntimeOptions,
-) {
-  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 as Record<string, unknown>)[
-      remote.entryGlobalName
-    ];
-    if (isRecord(globalEntry)) {
-      return globalEntry as unknown as BackendFederationEntryExports;
-    }
-  }
-
-  if (remote.type === 'module' || remote.entry.startsWith('file:')) {
-    return importModuleEntry(remote);
-  }
-
-  return evaluateBackendFederationCommonJsEntry(
-    remote,
-    new TextEncoder().encode(await readCommonJsEntrySource(remote)),
-    options.entryPolicy?.evaluateCommonJs,
-  );
-}
-
-export async function loadBackendFederationExpose(
-  remote: BackendFederationRemote,
-  expose: string,
-  options: BackendFederationRuntimeOptions,
-) {
-  const entry = await loadBackendFederationEntry(remote, options);
-  if (typeof entry.init === 'function') {
-    await entry.init({ hostName: options.hostName });
-  }
-  if (typeof entry.get !== 'function') {
-    throw new Error(
-      `[BFF][Effect] Backend federation remote ${remote.name} entry must expose get().`,
-    );
-  }
-  const factory = await entry.get(expose);
-  if (typeof factory !== 'function') {
-    throw new Error(
-      `[BFF][Effect] Backend federation expose ${remote.name}/${normalizeExpose(
-        expose,
-      )} must load factory function.`,
-    );
-  }
-  return factory();
-}

package/src/backend-federation/legacy-warning.ts

@@ -1,2 +0,0 @@
-export 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.';

package/src/client-generator/generator.ts

@@ -1,52 +0,0 @@
-import { collectEffectEndpoints } from '@modern-js/bff-effect/effect';
-import { logger } from '@modern-js/utils';
-import {
-  createEffectClientGeneration,
-  renderEffectClientCode,
-  renderEffectClientDeclaration,
-} from './rendering';
-import { getHttpApiRuntime, loadEffectApi } from './runtime';
-import type {
-  EffectClientCodegenOptions,
-  GeneratedEffectClientArtifacts,
-} from './types';
-
-export function generateEffectClient(
-  options: EffectClientCodegenOptions,
-): Promise<GeneratedEffectClientArtifacts | null> {
-  return loadEffectApi({
-    appDir: options.appDir,
-    resourcePath: options.resourcePath,
-    onDependency: options.onDependency,
-  }).then(api => {
-    if (api === null) {
-      logger.warn(
-        `[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`,
-      );
-      return null;
-    }
-
-    return getHttpApiRuntime().then(httpApiRuntime => {
-      const endpoints = collectEffectEndpoints(
-        httpApiRuntime.reflect,
-        api,
-        options.prefix,
-      );
-      const generation = createEffectClientGeneration(endpoints, options);
-      return {
-        code: renderEffectClientCode(generation),
-        declaration: renderEffectClientDeclaration(endpoints),
-        endpoints,
-        operationContracts: generation.operationContracts,
-        operationVersion: generation.operationVersion,
-        requestId: generation.requestId,
-      };
-    });
-  });
-}
-
-export function generateEffectClientCode(options: EffectClientCodegenOptions) {
-  return generateEffectClient(options).then(artifacts =>
-    artifacts === null ? null : artifacts.code,
-  );
-}

package/src/client-generator/index.ts

@@ -1,10 +0,0 @@
-export {
-  bundleBuiltEffectEntryForNode,
-  resolveEffectEntryPaths,
-} from './built-entry';
-export { generateEffectClient, generateEffectClientCode } from './generator';
-export { resolveEffectEntryFile } from './paths';
-export type {
-  EffectClientCodegenOptions,
-  GeneratedEffectClientArtifacts,
-} from './types';

package/src/client-generator/paths.ts

@@ -1,40 +0,0 @@
-import { findExists, fs, upath as path } from '@modern-js/utils';
-
-const JS_OR_TS_EXTS = [
-  '.js',
-  '.jsx',
-  '.ts',
-  '.tsx',
-  '.mjs',
-  '.mts',
-  '.cjs',
-  '.cts',
-] as const;
-
-export function resolveEffectEntryFile(options: {
-  appDir: string;
-  apiDir: string;
-  effectEntry?: string;
-}): string | undefined {
-  const { appDir, apiDir, effectEntry } = options;
-
-  const resolveEntry = (entryWithoutExt: string) => {
-    if (path.extname(entryWithoutExt) !== '') {
-      return fs.existsSync(entryWithoutExt) ? entryWithoutExt : undefined;
-    }
-
-    return (
-      findExists(JS_OR_TS_EXTS.map(ext => `${entryWithoutExt}${ext}`)) ||
-      undefined
-    );
-  };
-
-  if (effectEntry !== undefined && effectEntry !== '') {
-    const entryWithoutExt = path.isAbsolute(effectEntry)
-      ? effectEntry
-      : path.resolve(appDir, effectEntry);
-    return resolveEntry(entryWithoutExt);
-  }
-
-  return resolveEntry(path.resolve(apiDir, 'index'));
-}

package/src/client-generator/rendering.ts

@@ -1,307 +0,0 @@
-import {
-  buildOperationContractMap,
-  deriveOperationVersion,
-  type OperationContractMap,
-} from '@modern-js/bff-core';
-import {
-  createEffectEndpointContractHash,
-  type EffectEndpointMeta,
-  ensureLeadingSlash,
-  normalizeEffectPrefix,
-  toOperationContractSources,
-} from '@modern-js/bff-effect/effect';
-import { fs, upath as path } from '@modern-js/utils';
-import type { EffectClientCodegenOptions } from './types';
-
-const DEFAULT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
-const EFFECT_CLIENT_RUNTIME_IMPORT =
-  '@modern-js/plugin-bff/effect-client-runtime';
-
-function isAbsoluteUrl(value: string) {
-  try {
-    new URL(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function resolveBatchEndpoint(prefix: string, endpoint: string | undefined) {
-  const value =
-    endpoint === undefined || endpoint === '' ? '/_data/batch' : endpoint;
-  if (isAbsoluteUrl(value)) {
-    return value;
-  }
-
-  const normalizedPrefix = normalizeEffectPrefix(prefix);
-  const normalizedEndpoint = ensureLeadingSlash(value);
-  if (normalizedPrefix === '') {
-    return normalizedEndpoint;
-  }
-
-  if (
-    normalizedEndpoint === normalizedPrefix ||
-    normalizedEndpoint.startsWith(`${normalizedPrefix}/`)
-  ) {
-    return normalizedEndpoint;
-  }
-
-  return `${normalizedPrefix}${normalizedEndpoint === '/' ? '' : normalizedEndpoint}`;
-}
-
-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 {};
-}
-
-export type EffectClientGeneration = {
-  config: Record<string, unknown>;
-  manifest: {
-    endpoints: Array<{
-      apiId: string;
-      group: string;
-      endpoint: string;
-      method: string;
-      routePath: string;
-      schemaHash: string;
-      operationVersion: number;
-    }>;
-  };
-  operationContracts: OperationContractMap;
-  operationVersion: number;
-  requestCreator: string;
-  requestId: string;
-};
-
-export function renderEffectClientCode(generation: EffectClientGeneration) {
-  const { config, manifest } = generation;
-  return `import * as __requestRuntime from ${JSON.stringify(
-    generation.requestCreator,
-  )};
-import { createGeneratedEffectClient } from ${JSON.stringify(
-    EFFECT_CLIENT_RUNTIME_IMPORT,
-  )};
-
-const __manifest = ${JSON.stringify(manifest, null, 2)};
-
-const __config = ${JSON.stringify(config, null, 2)};
-
-const __generated = createGeneratedEffectClient(__manifest, __config, __requestRuntime);
-
-const client = __generated.client;
-const operationManifest = __generated.operationManifest;
-const createEffectRequestContext = __generated.createEffectRequestContext;
-const apiModule = {
-  client,
-  operationManifest,
-  createEffectRequestContext,
-};
-
-export { client, createEffectRequestContext, operationManifest };
-export default apiModule;
-`;
-}
-
-export function createEffectClientGeneration(
-  endpoints: EffectEndpointMeta[],
-  options: EffectClientCodegenOptions,
-): EffectClientGeneration {
-  const requestCreator = options.requestCreator || DEFAULT_REQUEST_CREATOR;
-  const httpMethodDecider = options.httpMethodDecider || 'functionName';
-  const packageInfo = getPackageInfo(
-    options.resourcePath,
-    options.appDir,
-    options.onDependency,
-  );
-  const packageName = packageInfo.name;
-  const dataPlatformAppNamespace =
-    packageName === undefined || packageName === ''
-      ? 'unknown-app'
-      : packageName;
-  const requestId =
-    options.target === 'bundle'
-      ? options.requestId !== undefined && options.requestId.trim() !== ''
-        ? options.requestId.trim()
-        : packageName !== undefined && packageName !== ''
-          ? packageName
-          : undefined
-      : undefined;
-  const normalizedRequestId =
-    requestId === undefined || requestId === '' ? 'default' : requestId;
-  const operationVersion = deriveOperationVersion(packageInfo.version);
-  const batchConfig = options.dataPlatformBatch;
-  const batchEndpoint = resolveBatchEndpoint(
-    options.prefix,
-    batchConfig?.endpoint,
-  );
-
-  const manifest = {
-    endpoints: endpoints.map(endpoint => ({
-      apiId: endpoint.apiId,
-      group: endpoint.groupName,
-      endpoint: endpoint.endpointName,
-      method: endpoint.method,
-      routePath: endpoint.routePath,
-      schemaHash: createEffectEndpointContractHash(
-        endpoint,
-        normalizedRequestId,
-      ),
-      operationVersion,
-    })),
-  };
-
-  const config = {
-    appNamespace: dataPlatformAppNamespace,
-    ...(requestId !== undefined && requestId !== '' ? { requestId } : {}),
-    port: options.port,
-    useEnvPort: options.target === 'server',
-    defaultOrigin: `http://localhost:${String(options.port)}`,
-    httpMethodDecider,
-    batch: {
-      enabled: batchConfig?.enabled ?? true,
-      endpoint: batchEndpoint,
-      flushIntervalMs: batchConfig?.flushIntervalMs ?? 8,
-      maxBatchSize: batchConfig?.maxBatchSize ?? 16,
-      maxBatchBytes: batchConfig?.maxBatchBytes ?? 64 * 1024,
-      requestTimeoutMs: batchConfig?.requestTimeoutMs ?? 10_000,
-      allowedMethods:
-        batchConfig?.allowedMethods !== undefined &&
-        batchConfig.allowedMethods.length > 0
-          ? batchConfig.allowedMethods
-          : ['GET'],
-    },
-  };
-
-  return {
-    config,
-    manifest,
-    operationContracts: buildOperationContractMap({
-      handlers: toOperationContractSources(endpoints),
-      requestId: normalizedRequestId,
-      operationVersion,
-    }),
-    operationVersion,
-    requestCreator,
-    requestId: normalizedRequestId,
-  };
-}
-
-function renderClientShape(
-  endpoints: EffectEndpointMeta[],
-  valueType: string,
-): string {
-  if (endpoints.length === 0) {
-    return `Record<string, Record<string, ${valueType}>>`;
-  }
-  const groups = new Map<string, string[]>();
-  for (const endpoint of endpoints) {
-    const group = groups.get(endpoint.groupName) || [];
-    group.push(endpoint.endpointName);
-    groups.set(endpoint.groupName, group);
-  }
-  const groupEntries = [...groups.entries()].map(([groupName, names]) => {
-    const endpointEntries = names
-      .map(name => `    ${JSON.stringify(name)}: ${valueType};`)
-      .join('\n');
-    return `  ${JSON.stringify(groupName)}: {\n${endpointEntries}\n  };`;
-  });
-  return `{\n${groupEntries.join('\n')}\n}`;
-}
-
-export function renderEffectClientDeclaration(
-  endpoints: EffectEndpointMeta[] = [],
-) {
-  return `export type EffectClientOperation = (
-  request?: unknown,
-) => Promise<unknown>;
-export type EffectClientGroup = Record<string, EffectClientOperation>;
-export type EffectClient = Record<string, EffectClientGroup>;
-export type EffectOperationDescriptor = {
-  appNamespace: string;
-  apiId: string;
-  group: string;
-  endpoint: string;
-  operationId: string;
-  routePath: string;
-  method: string;
-  operationVersion: number;
-  schemaHash: string;
-  version: number;
-};
-export type EffectOperationManifest = Record<
-  string,
-  Record<string, EffectOperationDescriptor>
->;
-export type EffectOperationContext = {
-  requestId?: string;
-  operationId?: string;
-  routePath?: string;
-  method?: string;
-  schemaHash?: string;
-  operationVersion?: number;
-  locale?: string;
-  traceparent?: string;
-  traceId?: string;
-  spanId?: string;
-  source?: string;
-  scope?: Record<string, unknown>;
-  sessionClaims?: Record<string, unknown>;
-  attributes?: Record<string, unknown>;
-};
-export type EffectRequestContext = {
-  headers?: Record<string, string>;
-  locale?: string;
-  operationContext?: EffectOperationContext;
-  traceparent?: string;
-  traceId?: string;
-  spanId?: string;
-};
-export type GeneratedEffectClient = ${renderClientShape(
-    endpoints,
-    'EffectClientOperation',
-  )};
-export type GeneratedEffectOperationManifest = ${renderClientShape(
-    endpoints,
-    'EffectOperationDescriptor',
-  )};
-
-export declare const client: GeneratedEffectClient;
-export declare const createEffectRequestContext: (
-  requestContext: Record<string, unknown>,
-) => EffectRequestContext;
-export declare const operationManifest: GeneratedEffectOperationManifest;
-declare const apiModule: {
-  client: GeneratedEffectClient;
-  createEffectRequestContext: typeof createEffectRequestContext;
-  operationManifest: GeneratedEffectOperationManifest;
-};
-
-export default apiModule;
-`;
-}

package/src/client-generator/runtime.ts

@@ -1,69 +0,0 @@
-import {
-  extractHttpApiFromModule,
-  type HttpApiLike,
-  type HttpApiReflect,
-} from '@modern-js/bff-effect/effect';
-import { compatibleRequire, upath as path } from '@modern-js/utils';
-import { loadEffectSourceModule } from '../effect-source-loader/loader';
-
-type HttpApiRuntime = {
-  isHttpApi: (value: unknown) => boolean;
-  reflect: HttpApiReflect;
-};
-
-let httpApiRuntimePromise: Promise<HttpApiRuntime> | undefined;
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null;
-}
-
-function isHttpApiRuntime(value: unknown): value is HttpApiRuntime {
-  return (
-    isRecord(value) &&
-    typeof value.isHttpApi === 'function' &&
-    typeof value.reflect === 'function'
-  );
-}
-
-export function getHttpApiRuntime(): Promise<HttpApiRuntime> {
-  if (httpApiRuntimePromise === undefined) {
-    httpApiRuntimePromise = compatibleRequire('effect/unstable/httpapi', false)
-      .catch(error => {
-        const message = error instanceof Error ? error.message : String(error);
-        if (!message.includes("Cannot find module 'effect/unstable/httpapi'")) {
-          throw error;
-        }
-        const effectPackageJson = require.resolve('effect/package.json');
-        const effectHttpApiRuntimePath = path.join(
-          path.dirname(effectPackageJson),
-          'dist',
-          'unstable',
-          'httpapi',
-          'index.js',
-        );
-        return compatibleRequire(effectHttpApiRuntimePath, false);
-      })
-      .then(mod => {
-        if (isRecord(mod) && isHttpApiRuntime(mod.HttpApi)) {
-          return mod.HttpApi;
-        }
-        throw new Error(
-          '[BFF][Effect] Unable to resolve HttpApi runtime from effect/unstable/httpapi.',
-        );
-      });
-  }
-
-  return httpApiRuntimePromise;
-}
-
-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/client-generator/types.ts

@@ -1,35 +0,0 @@
-import type { OperationContractMap } from '@modern-js/bff-core';
-import type { EffectEndpointMeta } from '@modern-js/bff-effect/effect';
-import type { HttpMethodDecider } from '@modern-js/types';
-
-export type EffectClientCodegenOptions = {
-  appDir: string;
-  apiDir: string;
-  resourcePath: string;
-  prefix: string;
-  port: number;
-  target?: string;
-  /** Producer identity used by cross-project clients and server contracts. */
-  requestId?: string;
-  requestCreator?: string;
-  httpMethodDecider?: HttpMethodDecider;
-  onDependency?: (dependency: string) => void;
-  dataPlatformBatch?: {
-    enabled?: boolean;
-    endpoint?: string;
-    flushIntervalMs?: number;
-    maxBatchSize?: number;
-    maxBatchBytes?: number;
-    requestTimeoutMs?: number;
-    allowedMethods?: string[];
-  };
-};
-
-export type GeneratedEffectClientArtifacts = {
-  code: string;
-  declaration: string;
-  endpoints: EffectEndpointMeta[];
-  operationContracts: OperationContractMap;
-  operationVersion: number;
-  requestId: string;
-};