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

package/src/cross-project-policy/producer-runtime.ts

@@ -0,0 +1,43 @@
+interface ProducerClientOptions {
+  requestId?: string;
+  requireEnvelope?: boolean;
+  identityBinding?: {
+    enabled?: boolean;
+    strict?: boolean;
+    protectedHeaders?: string[];
+  };
+  operationContract?: {
+    enabled?: boolean;
+    strict?: boolean;
+    requireSchemaHash?: boolean;
+    requireOperationVersion?: boolean;
+  };
+}
+
+/** Bind producer defaults once while preserving every per-call nested override. */
+export function createProducerClient<
+  Options extends ProducerClientOptions,
+  Result,
+>(
+  configure: (options: Options) => Result,
+  { requestId }: { requestId: string },
+) {
+  return (options?: Options): Result =>
+    configure({
+      requestId,
+      requireEnvelope: true,
+      ...options,
+      identityBinding: {
+        enabled: true,
+        strict: true,
+        ...options?.identityBinding,
+      },
+      operationContract: {
+        enabled: true,
+        strict: true,
+        requireSchemaHash: true,
+        requireOperationVersion: true,
+        ...options?.operationContract,
+      },
+    } as Options);
+}

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 { 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,242 @@
+// @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),
+            }))) 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);
+    });
+  },
+});

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

@@ -1,8 +1,10 @@
 import { fs, upath as path } from '@modern-js/utils';
 
-import { resolveEffectEntryFile } from './paths';
-
-const BUILT_ENTRY_EXT = /\.(?:[cm]?ts|tsx|jsx)$/u;
+import {
+  emittedEffectEntry,
+  relativeEffectAppPath,
+  resolveEffectEntryFile,
+} from './paths';
 
 export function resolveBuiltEffectEntry(
   appDirectory: string,
@@ -12,15 +14,15 @@ export function resolveBuiltEffectEntry(
   if (sourceEntry === undefined || sourceEntry.length === 0) {
     return undefined;
   }
-  const relativeEntry = path.relative(appDirectory, sourceEntry);
-  if (relativeEntry === '..' || relativeEntry.startsWith(`..${path.sep}`)) {
+  const relativeEntry = relativeEffectAppPath(appDirectory, sourceEntry);
+  if (relativeEntry === undefined) {
     throw new Error(
       `Effect BFF entry must be inside the application directory: ${sourceEntry}`,
     );
   }
-  const builtEntry = path
-    .resolve(distDirectory, relativeEntry)
-    .replace(BUILT_ENTRY_EXT, '.js');
+  const builtEntry = emittedEffectEntry(
+    path.resolve(distDirectory, relativeEntry),
+  );
   return fs.existsSync(builtEntry) ? builtEntry : undefined;
 }
 
@@ -41,9 +43,7 @@ export async function bundleBuiltEffectEntryForNode(options: {
       }`,
     );
   }
-  const { bundleEffectEntryForNode } = await import(
-    '../effect-source-loader/loader'
-  );
+  const { bundleEffectEntryForNode } = await import('./loader');
   return bundleEffectEntryForNode({
     appDir,
     entryPath: builtEntry,
@@ -64,7 +64,7 @@ export function resolveEffectEntryPaths(options: {
   });
   const relativeEffectEntry =
     sourceEffectEntry !== undefined && sourceEffectEntry.length > 0
-      ? path.relative(appDir, sourceEffectEntry).replace(BUILT_ENTRY_EXT, '.js')
+      ? emittedEffectEntry(path.relative(appDir, sourceEffectEntry))
       : '';
   return { sourceEffectEntry, relativeEffectEntry };
 }

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,6 +1,9 @@
-export { resolveEffectEntryFile } from '../client-generator/paths';
-export { bundleEffectEntryForNode } from './loader';
 export {
-  generateEffectClientCode,
-  generateEffectWorkerRuntimeWrapper,
-} from './worker-runtime-wrapper';
+  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 { generateEffectWorkerRuntimeWrapper } from './worker-runtime-wrapper';

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

@@ -39,31 +39,37 @@ function preserveSourceModuleSemantics(): Plugin {
   return {
     name: 'modern-js-effect-source-semantics',
     setup(buildApi) {
-      buildApi.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, async args => {
-        const loader = sourceLoader(args);
-        if (!loader) {
-          return undefined;
-        }
+      buildApi.onLoad(
+        { filter: /\.[cm]?[jt]sx?$/, namespace: 'file' },
+        async args => {
+          const loader = sourceLoader(args);
+          if (!loader) {
+            return undefined;
+          }
 
-        const source = await fs.promises.readFile(args.path, 'utf8');
-        const compiled = await transform(source, {
-          define: {
-            __dirname: JSON.stringify(path.dirname(args.path)),
-            __filename: JSON.stringify(args.path),
-            'import.meta.url': JSON.stringify(pathToFileURL(args.path).href),
-          },
-          jsx: 'automatic',
-          loader,
-          sourcefile: args.path,
-          target: NODE_TARGET,
-        });
+          const source = await fs.promises.readFile(args.path, 'utf8');
+          const canonicalSourcePath = await fs.promises.realpath(args.path);
+          const compiled = await transform(source, {
+            define: {
+              __dirname: JSON.stringify(path.dirname(canonicalSourcePath)),
+              __filename: JSON.stringify(canonicalSourcePath),
+              'import.meta.url': JSON.stringify(
+                pathToFileURL(canonicalSourcePath).href,
+              ),
+            },
+            jsx: 'automatic',
+            loader,
+            sourcefile: args.path,
+            target: NODE_TARGET,
+          });
 
-        return {
-          contents: compiled.code,
-          loader: 'js',
-          resolveDir: path.dirname(args.path),
-        };
-      });
+          return {
+            contents: compiled.code,
+            loader: 'js',
+            resolveDir: path.dirname(args.path),
+          };
+        },
+      );
     },
   };
 }
@@ -73,6 +79,9 @@ const nodeBuiltins = new Set([
   ...builtinModules.map(name => `node:${name}`),
 ]);
 const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
+// The BFF server runs lambdas inside these packages' Effect context storage.
+// A bundled copy would own a second storage that the server never enters.
+const BFF_RUNTIME_PACKAGE = /^@modern-js\/(?:bff-effect|plugin-bff)(?:\/|$)/;
 
 async function isEsmOnlyFile(filename: string) {
   const extension = path.extname(filename).toLowerCase();
@@ -119,22 +128,20 @@ function isBareSpecifier(specifier: string) {
 }
 
 /**
- * Keep installed registry dependencies external while bundling symlinked
- * workspace source packages. Registry packages remain executable from the
- * deployment node_modules tree; workspace TypeScript is bundled so the
- * generated entry is relocatable and directly executable by Node 26.7.
+ * Keep installed executable dependencies external to preserve runtime identity.
+ * Source requiring compilation is bundled even when pnpm injects a workspace
+ * package into node_modules: Node does not strip types inside that directory.
  */
 function externalizeInstalledDependencies(options: {
-  format: 'cjs' | 'esm';
   runtimeResolveDir: string;
 }): Plugin {
-  const runtimeRequire = createRequire(
-    path.join(options.runtimeResolveDir, '__modern_effect_entry.cjs'),
-  );
   return {
     name: 'modern-js-effect-installed-dependencies',
     setup(buildApi) {
       buildApi.onResolve({ filter: /.*/ }, async args => {
+        if (BFF_RUNTIME_PACKAGE.test(args.path)) {
+          return { external: true, path: args.path };
+        }
         if (
           !isBareSpecifier(args.path) ||
           nodeBuiltins.has(args.path) ||
@@ -165,7 +172,13 @@ function externalizeInstalledDependencies(options: {
         const realPath = await fs.promises
           .realpath(resolution.path)
           .catch(() => resolution.path);
-        if (realPath.includes(`${path.sep}node_modules${path.sep}`)) {
+        const loader = SOURCE_LOADERS.get(path.extname(realPath).toLowerCase());
+        if (
+          realPath.includes(`${path.sep}node_modules${path.sep}`) &&
+          loader !== 'ts' &&
+          loader !== 'tsx' &&
+          loader !== 'jsx'
+        ) {
           const runtimeResolution = await buildApi.resolve(args.path, {
             importer: '',
             kind: args.kind,
@@ -176,24 +189,8 @@ function externalizeInstalledDependencies(options: {
             resolveDir: options.runtimeResolveDir,
           });
           if (runtimeResolution.errors.length === 0 && runtimeResolution.path) {
-            if (options.format === 'cjs') {
-              let requiredPath: string;
-              try {
-                requiredPath = runtimeRequire.resolve(args.path);
-              } catch {
-                requiredPath = runtimeResolution.path;
-              }
-              if (await isEsmOnlyFile(requiredPath)) {
-                return {
-                  namespace: resolution.namespace,
-                  path: resolution.path,
-                  pluginData: resolution.pluginData,
-                  sideEffects: resolution.sideEffects,
-                  suffix: resolution.suffix,
-                  warnings: resolution.warnings,
-                };
-              }
-            }
+            // Node 26 loads installed ESM from CommonJS natively. Rebundling
+            // it here would split dependency identity from the BFF runtime.
             return { external: true, path: args.path };
           }
         }
@@ -227,7 +224,6 @@ export async function bundleEffectEntryForNode(options: {
     platform: 'node',
     plugins: [
       externalizeInstalledDependencies({
-        format: options.format,
         runtimeResolveDir: options.appDir,
       }),
       preserveSourceModuleSemantics(),
@@ -365,7 +361,6 @@ export async function loadEffectSourceModule(
     platform: 'node',
     plugins: [
       externalizeInstalledDependencies({
-        format: 'esm',
         runtimeResolveDir: appDir,
       }),
       preserveSourceModuleSemantics(),

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

@@ -0,0 +1,38 @@
+import {
+  collectEffectEndpoints,
+  toOperationContractSources,
+} from '@modern-js/bff-effect/effect';
+import {
+  buildOperationContractMap,
+  resolveOperationProducer,
+} from '@modern-js/server-runtime-extensions/bff-policy/node';
+import { upath as path } from '@modern-js/utils';
+import { getHttpApiRuntime, loadEffectApi } from './http-api-runtime';
+
+/** 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,
+  );
+  return buildOperationContractMap({
+    handlers: toOperationContractSources(endpoints),
+    ...resolveOperationProducer({
+      directories: [path.dirname(options.resourcePath), options.appDir],
+      requestId: options.requestId,
+      onDependency: options.onDependency,
+    }),
+  });
+}