@bleedingdev/modern-js-plugin-bff-extensions 3.8.3-ultramodern.2

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

@@ -0,0 +1,63 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import {
+  deriveOperationVersion,
+  type OperationContractSource,
+  resolveCrossProjectPolicy,
+} from '@modern-js/bff-core';
+import type { ServerPluginAPI } from '@modern-js/server-core';
+
+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[],
+): ResolvedCrossProjectPolicy | undefined => {
+  const bff = api.getServerConfig()?.bff;
+  const { apiDirectory, appDirectory } = api.getServerContext() as {
+    apiDirectory?: string;
+    appDirectory?: string;
+  };
+
+  return resolveCrossProjectPolicy({
+    crossProjectPolicy: bff?.crossProjectPolicy,
+    handlers,
+    requestId: bff?.requestId,
+    isCrossProjectServer: bff?.isCrossProjectServer,
+    operationVersion: deriveOperationVersion(
+      readNearestPackageVersion(apiDirectory) ??
+        readNearestPackageVersion(appDirectory),
+    ),
+  });
+};

package/src/effect-adapter/cross-project-policy.ts

@@ -0,0 +1,63 @@
+// @effect-diagnostics strictBooleanExpressions:off
+import {
+  collectEffectEndpoints,
+  type EffectApiModule,
+  extractHttpApiFromModule,
+  toOperationContractSources,
+} from '@modern-js/bff-effect/effect';
+import type { ServerPluginAPI } from '@modern-js/server-core';
+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(
+  api: ServerPluginAPI,
+  prefix: string,
+  mod: EffectApiModule | null,
+): Promise<ResolvedCrossProjectPolicy | undefined> {
+  const contractSourcesPromise =
+    mod === null
+      ? Promise.resolve([])
+      : Promise.resolve()
+          .then(() => extractHttpApiFromModule(mod, HttpApi.isHttpApi))
+          .then(effectApi => {
+            if (effectApi === null) {
+              return [];
+            }
+            const reflect: Parameters<typeof collectEffectEndpoints>[0] = (
+              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),
+            );
+          })
+          .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 && 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.',
+      );
+    }
+    return policy;
+  });
+}

package/src/effect-adapter/entry.ts

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

package/src/effect-adapter/error-response.ts

@@ -0,0 +1,68 @@
+import { createSafeFailureResponse } from '@modern-js/runtime-extensions/safe-failure';
+import type { Context, ServerPluginAPI } from '@modern-js/server-core';
+import { logger } from '@modern-js/utils';
+
+export function createEffectAdapterRuntimeErrorResponse(
+  api: ServerPluginAPI,
+  error: unknown,
+  context: Context,
+): Promise<Response> {
+  try {
+    const onError = api.getServerConfig()?.onError;
+    if (onError !== undefined) {
+      return Promise.resolve(
+        onError(
+          error instanceof Error ? error : new Error(String(error)),
+          ensureJsonContext(context),
+        ),
+      )
+        .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(context: Context): Context {
+  if ('json' in context && typeof context.json === 'function') {
+    return context;
+  }
+
+  return Object.assign({}, context, {
+    json(
+      data: unknown,
+      statusOrInit: number | ResponseInit = 200,
+      extraHeaders?: HeadersInit,
+    ) {
+      const responseInit =
+        typeof statusOrInit === 'number'
+          ? { status: statusOrInit, headers: extraHeaders }
+          : statusOrInit;
+      const responseHeaders = new Headers({
+        'content-type': 'application/json; charset=utf-8',
+      });
+      if (responseInit.headers !== undefined) {
+        new Headers(responseInit.headers).forEach((value, key) => {
+          responseHeaders.set(key, value);
+        });
+      }
+      return new Response(JSON.stringify(data), {
+        ...responseInit,
+        headers: responseHeaders,
+      });
+    },
+  });
+}

package/src/effect-adapter/index.ts

@@ -0,0 +1,246 @@
+// @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off nodeBuiltinImport:off strictBooleanExpressions:off
+
+import path from 'node:path';
+import {
+  dispatchEffectBffRequest,
+  type EffectApiModule,
+  type EffectBffRequestHandler,
+  resolveEffectBffModuleHandler,
+  useEffectContext,
+} from '@modern-js/bff-effect/effect';
+import type { Context, Next, ServerPluginAPI } from '@modern-js/server-core';
+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 { resolveEffectAdapterCrossProjectPolicy } from './cross-project-policy';
+import { resolveEffectAdapterEntryFile } from './entry';
+import { createEffectAdapterRuntimeErrorResponse } from './error-response';
+
+const EFFECT_MIDDLEWARE_BEFORE = [
+  'custom-server-hook',
+  'custom-server-middleware',
+  'render',
+];
+
+interface EffectAdapterMiddlewareOptions {
+  prefix: string | readonly string[];
+  enableHandleWeb?: boolean;
+}
+
+export class EffectAdapter {
+  private api: ServerPluginAPI;
+
+  private handler: DisposableServerRuntimeHandle | null = null;
+  private unregisterRuntimeDisposer?: () => void;
+  private prefix = '/api';
+  private prefixes = ['/api'];
+  private matchingPrefixes = ['/api'];
+  private retired = false;
+
+  constructor(api: ServerPluginAPI) {
+    this.api = api;
+  }
+
+  registerMiddleware = async (options: EffectAdapterMiddlewareOptions) => {
+    const { enableHandleWeb } = options;
+    const { bffRuntimeFramework, middlewares: globalMiddlewares } =
+      this.api.getServerContext();
+
+    if (bffRuntimeFramework === 'hono') {
+      return;
+    }
+
+    const configuredPrefixes = Array.isArray(options.prefix)
+      ? options.prefix.filter(Boolean)
+      : [options.prefix || '/api'];
+    this.prefixes = [
+      ...new Set(configuredPrefixes.length > 0 ? configuredPrefixes : ['/api']),
+    ];
+    this.matchingPrefixes = [...this.prefixes].sort(
+      (left, right) => right.length - left.length,
+    );
+    this.prefix = this.prefixes[0] || '/api';
+    const { serverBase } = this.api.getServerContext() as {
+      serverBase?: object;
+    };
+    if (serverBase) {
+      this.unregisterRuntimeDisposer = registerServerRuntimeDisposer(
+        serverBase,
+        this.dispose,
+      );
+    }
+
+    try {
+      await this.loadHandler();
+    } catch (error) {
+      await this.dispose();
+      throw error;
+    }
+
+    const middlewarePrefixes = enableHandleWeb
+      ? [this.prefix]
+      : this.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 handler = this.handler;
+        if (!handler) {
+          if (enableHandleWeb) {
+            await next();
+            return;
+          }
+          return createEffectAdapterRuntimeErrorResponse(
+            this.api,
+            new Error(
+              '[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.',
+            ),
+            context,
+          );
+        }
+
+        const prefix = enableHandleWeb
+          ? this.matchingPrefixes.find(
+              item =>
+                item === '/' ||
+                context.req.path === item ||
+                context.req.path.startsWith(`${item}/`),
+            ) || this.prefix
+          : middlewarePrefix;
+        const response = await dispatchEffectBffRequest(
+          handler as EffectBffRequestHandler,
+          context.req.raw,
+          {
+            prefix,
+            env: context.env as Record<string, unknown>,
+            path: context.req.path,
+            method: context.req.method,
+            onError: error =>
+              createEffectAdapterRuntimeErrorResponse(this.api, error, context),
+          },
+        );
+
+        if (response.status === 404 && enableHandleWeb) {
+          await next();
+          return;
+        }
+
+        return new Response(response.body, response);
+      },
+    }));
+
+    globalMiddlewares.push(...middlewares);
+  };
+
+  dispose = async () => {
+    this.retired = true;
+    this.unregisterRuntimeDisposer?.();
+    this.unregisterRuntimeDisposer = undefined;
+    const previous = this.handler;
+    this.handler = null;
+    await previous?.dispose();
+  };
+
+  private async loadHandler() {
+    const entryFile = resolveEffectAdapterEntryFile(this.api);
+    if (!entryFile || !(await fs.pathExists(entryFile))) {
+      this.handler = null;
+      return;
+    }
+
+    let mod: EffectApiModule;
+    try {
+      const { appDirectory } = this.api.getServerContext();
+      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 crossProjectPolicies = new Map(
+      await Promise.all(
+        this.prefixes.map(
+          async prefix =>
+            [
+              prefix,
+              await resolveEffectAdapterCrossProjectPolicy(
+                this.api,
+                prefix,
+                mod,
+              ),
+            ] as const,
+        ),
+      ),
+    );
+    const effectConfig = this.api.getServerConfig()?.bff?.effect;
+    const loaded = await resolveEffectBffModuleHandler(mod, {
+      openapi: effectConfig?.openapi,
+      dataPlatform: effectConfig?.dataPlatform,
+      validateRequest: request => {
+        const { path: mountedPathname } = useEffectContext();
+        const prefix = this.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 (this.retired) {
+      await candidate.dispose();
+      throw new Error('Cannot initialize a retired Effect adapter.');
+    }
+    this.handler = candidate;
+  }
+}

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

@@ -0,0 +1,6 @@
+export { resolveEffectEntryFile } from '../client-generator/paths';
+export { bundleEffectEntryForNode } from './loader';
+export {
+  generateEffectClientCode,
+  generateEffectWorkerRuntimeWrapper,
+} from './worker-runtime-wrapper';