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

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

@@ -0,0 +1,397 @@
+// Node-only source loading implementation; the public surface lives in index.ts.
+// @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off nodeBuiltinImport:off strictBooleanExpressions:off
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import { builtinModules, createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import {
+  build,
+  type Loader,
+  type OnLoadArgs,
+  type Plugin,
+  transform,
+} from 'esbuild';
+
+const NODE_TARGET = 'node26.7';
+const SOURCE_LOADERS = new Map<string, Loader>([
+  ['.js', 'js'],
+  ['.jsx', 'jsx'],
+  ['.mjs', 'js'],
+  ['.cjs', 'js'],
+  ['.ts', 'ts'],
+  ['.tsx', 'tsx'],
+  ['.mts', 'ts'],
+  ['.cts', 'ts'],
+]);
+
+export type EffectSourceLoaderOptions = {
+  resourcePath: string;
+  appDir?: string;
+  onDependency?: (dependency: string) => void;
+};
+
+function sourceLoader(args: OnLoadArgs): Loader | undefined {
+  return SOURCE_LOADERS.get(path.extname(args.path).toLowerCase());
+}
+
+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;
+        }
+
+        const source = await fs.promises.readFile(args.path, 'utf8');
+        const compiled = await transform(source, {
+          define: {
+            'import.meta.url': JSON.stringify(pathToFileURL(args.path).href),
+          },
+          jsx: 'automatic',
+          loader,
+          sourcefile: args.path,
+          target: NODE_TARGET,
+        });
+
+        return {
+          contents: compiled.code,
+          loader: 'js',
+          resolveDir: path.dirname(args.path),
+        };
+      });
+    },
+  };
+}
+
+const nodeBuiltins = new Set([
+  ...builtinModules,
+  ...builtinModules.map(name => `node:${name}`),
+]);
+const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
+
+async function isEsmOnlyFile(filename: string) {
+  const extension = path.extname(filename).toLowerCase();
+  if (extension === '.mjs' || extension === '.mts') {
+    return true;
+  }
+  if (extension === '.cjs' || extension === '.cts') {
+    return false;
+  }
+
+  let directory = path.dirname(filename);
+  while (true) {
+    const packagePath = path.join(directory, 'package.json');
+    try {
+      const packageJson = JSON.parse(
+        await fs.promises.readFile(packagePath, 'utf8'),
+      ) as { type?: unknown };
+      return packageJson.type === 'module';
+    } catch (error) {
+      if (
+        !error ||
+        typeof error !== 'object' ||
+        !('code' in error) ||
+        error.code !== 'ENOENT'
+      ) {
+        throw error;
+      }
+    }
+
+    const parent = path.dirname(directory);
+    if (parent === directory) {
+      return false;
+    }
+    directory = parent;
+  }
+}
+
+function isBareSpecifier(specifier: string) {
+  return (
+    !specifier.startsWith('.') &&
+    !specifier.startsWith('/') &&
+    !path.isAbsolute(specifier)
+  );
+}
+
+/**
+ * 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.
+ */
+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 (
+          !isBareSpecifier(args.path) ||
+          nodeBuiltins.has(args.path) ||
+          args.pluginData?.[dependencyResolutionMarker] === true
+        ) {
+          return nodeBuiltins.has(args.path)
+            ? { external: true, path: args.path }
+            : undefined;
+        }
+
+        const resolution = await buildApi.resolve(args.path, {
+          importer: args.importer,
+          kind: args.kind,
+          namespace: args.namespace,
+          pluginData: {
+            ...args.pluginData,
+            [dependencyResolutionMarker]: true,
+          },
+          resolveDir: args.resolveDir,
+        });
+        if (resolution.errors.length > 0) {
+          return { external: true, path: args.path };
+        }
+        if (resolution.external || !resolution.path) {
+          return { external: true, path: args.path };
+        }
+
+        const realPath = await fs.promises
+          .realpath(resolution.path)
+          .catch(() => resolution.path);
+        if (realPath.includes(`${path.sep}node_modules${path.sep}`)) {
+          const runtimeResolution = await buildApi.resolve(args.path, {
+            importer: '',
+            kind: args.kind,
+            namespace: 'file',
+            pluginData: {
+              [dependencyResolutionMarker]: true,
+            },
+            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,
+                };
+              }
+            }
+            return { external: true, path: args.path };
+          }
+        }
+
+        return {
+          namespace: resolution.namespace,
+          path: resolution.path,
+          pluginData: resolution.pluginData,
+          sideEffects: resolution.sideEffects,
+          suffix: resolution.suffix,
+          warnings: resolution.warnings,
+        };
+      });
+    },
+  };
+}
+
+export async function bundleEffectEntryForNode(options: {
+  appDir: string;
+  entryPath: string;
+  format: 'cjs' | 'esm';
+}) {
+  await build({
+    absWorkingDir: options.appDir,
+    allowOverwrite: true,
+    bundle: true,
+    entryPoints: [options.entryPath],
+    format: options.format,
+    logLevel: 'silent',
+    outfile: options.entryPath,
+    platform: 'node',
+    plugins: [
+      externalizeInstalledDependencies({
+        format: options.format,
+        runtimeResolveDir: options.appDir,
+      }),
+      preserveSourceModuleSemantics(),
+    ],
+    target: NODE_TARGET,
+  });
+}
+
+function isWatchableInput(filename: string) {
+  return (
+    !filename.includes(`${path.sep}node_modules${path.sep}`) &&
+    (SOURCE_LOADERS.has(path.extname(filename).toLowerCase()) ||
+      path.extname(filename).toLowerCase() === '.json')
+  );
+}
+
+function normalizeImportedModule(module: unknown): unknown {
+  if (!module || typeof module !== 'object') {
+    return module;
+  }
+  const namespace = module as Record<string, unknown>;
+  const commonJsModule = namespace.default;
+  if (
+    Object.keys(namespace).length === 1 &&
+    commonJsModule !== null &&
+    typeof commonJsModule === 'object' &&
+    (commonJsModule as Record<string, unknown>).__esModule === true
+  ) {
+    return commonJsModule;
+  }
+  return module;
+}
+
+function hasErrorCode(error: unknown, code: string): boolean {
+  return (
+    error !== null &&
+    typeof error === 'object' &&
+    'code' in error &&
+    error.code === code
+  );
+}
+
+async function publishImmutableOutput(options: {
+  cacheDirectory: string;
+  contents: Uint8Array;
+  outputName: string;
+}): Promise<string> {
+  const revision = crypto
+    .createHash('sha256')
+    .update(options.contents)
+    .digest('hex');
+  const outputPath = path.join(
+    options.cacheDirectory,
+    `${options.outputName}-${revision}.mjs`,
+  );
+  const temporaryPath = path.join(
+    options.cacheDirectory,
+    `.${options.outputName}-${crypto.randomUUID()}.tmp`,
+  );
+
+  try {
+    await fs.promises.writeFile(temporaryPath, options.contents, {
+      flag: 'wx',
+    });
+    try {
+      await fs.promises.link(temporaryPath, outputPath);
+    } catch (error) {
+      if (!hasErrorCode(error, 'EEXIST')) {
+        throw error;
+      }
+
+      const publishedContents = await fs.promises.readFile(outputPath);
+      if (!publishedContents.equals(Buffer.from(options.contents))) {
+        throw new Error(
+          `Effect source cache entry does not match its content address: ${outputPath}`,
+        );
+      }
+    }
+  } finally {
+    await fs.promises.rm(temporaryPath, { force: true });
+  }
+
+  return outputPath;
+}
+
+/** Loads a production artifact without changing its native Node boundary. */
+export async function loadEffectBuiltModule(
+  resourcePath: string,
+): Promise<unknown> {
+  const canonicalPath = await fs.promises.realpath(path.resolve(resourcePath));
+  if (!(await isEsmOnlyFile(canonicalPath))) {
+    return createRequire(canonicalPath)(canonicalPath);
+  }
+  return normalizeImportedModule(
+    await import(pathToFileURL(canonicalPath).href),
+  );
+}
+
+/**
+ * Loads an Effect source entry as native ESM while reporting its complete
+ * local source graph to the framework watcher.
+ */
+export async function loadEffectSourceModule(
+  options: EffectSourceLoaderOptions,
+): Promise<unknown> {
+  const resourcePath = path.resolve(options.resourcePath);
+  const appDir = path.resolve(options.appDir ?? path.dirname(resourcePath));
+  const tsconfigPath = path.join(appDir, 'tsconfig.json');
+  const cacheDirectory = path.join(
+    appDir,
+    'node_modules',
+    '.cache',
+    'modern-js',
+    'effect-source-loader',
+  );
+  const outputName = crypto
+    .createHash('sha256')
+    .update(resourcePath)
+    .digest('hex')
+    .slice(0, 24);
+  await fs.promises.mkdir(cacheDirectory, { recursive: true });
+
+  const result = await build({
+    absWorkingDir: appDir,
+    banner: {
+      js: `import { createRequire as __modernCreateEffectRequire } from 'node:module'; const require = __modernCreateEffectRequire(${JSON.stringify(pathToFileURL(resourcePath).href)});`,
+    },
+    bundle: true,
+    entryPoints: [resourcePath],
+    format: 'esm',
+    jsx: 'automatic',
+    logLevel: 'silent',
+    metafile: true,
+    outfile: path.join(cacheDirectory, `${outputName}.mjs`),
+    platform: 'node',
+    plugins: [
+      externalizeInstalledDependencies({
+        format: 'esm',
+        runtimeResolveDir: appDir,
+      }),
+      preserveSourceModuleSemantics(),
+    ],
+    sourcemap: 'inline',
+    target: NODE_TARGET,
+    tsconfig: fs.existsSync(tsconfigPath) ? tsconfigPath : undefined,
+    write: false,
+  });
+
+  for (const input of Object.keys(result.metafile.inputs)) {
+    const dependency = path.isAbsolute(input)
+      ? path.normalize(input)
+      : path.resolve(appDir, input);
+    if (isWatchableInput(dependency)) {
+      options.onDependency?.(dependency);
+    }
+  }
+
+  if (result.outputFiles.length !== 1) {
+    throw new Error(
+      `Expected one Effect source output, received ${result.outputFiles.length}`,
+    );
+  }
+  const outputPath = await publishImmutableOutput({
+    cacheDirectory,
+    contents: result.outputFiles[0].contents,
+    outputName,
+  });
+  return normalizeImportedModule(await import(pathToFileURL(outputPath).href));
+}

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

@@ -0,0 +1,90 @@
+// @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;
+};
+
+export async function generateEffectWorkerRuntimeWrapper(
+  loader: { addDependency: (dependency: string) => void },
+  options: EffectWorkerRuntimeGenerationOptions,
+  resourcePath: string,
+) {
+  const { generateEffectClient } = await import(
+    '../client-generator/generator'
+  );
+  const artifacts = await generateEffectClient({
+    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 { createEffectBffEdgeDispatcher } from '@modern-js/plugin-bff/effect-edge/dispatcher';
+
+const __generatedOperationContracts = ${JSON.stringify(operationContracts)};
+
+const __mergeGeneratedOperationContracts = policy => {
+  if (
+    !policy ||
+    !policy.expectedOperationContracts ||
+    typeof policy.expectedOperationContracts !== 'object' ||
+    Array.isArray(policy.expectedOperationContracts)
+  ) {
+    return policy;
+  }
+  return {
+    ...policy,
+    expectedOperationContracts: {
+      ...policy.expectedOperationContracts,
+      ...__generatedOperationContracts,
+    },
+  };
+};
+
+export const __modern_create_effect_bff_dispatcher = options =>
+  createEffectBffEdgeDispatcher({
+    ...options,
+    crossProjectPolicy: __mergeGeneratedOperationContracts(
+      options?.crossProjectPolicy,
+    ),
+    module: effectBffModule,
+  });
+`;
+}
+
+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/src/hono/bind-route-handlers.ts

@@ -0,0 +1,62 @@
+import { createSafeFailureResponse } from '@modern-js/runtime-extensions/safe-failure';
+import type { Context, MiddlewareHandler } from '@modern-js/server-core';
+
+import type { ResolvedCrossProjectPolicy } from '../cross-project-policy/evaluation';
+import { createHonoCrossProjectPolicyMiddleware } from './cross-project-policy';
+
+export interface BindHonoRouteHandlersOptions {
+  handler: MiddlewareHandler | MiddlewareHandler[];
+  policy?: ResolvedCrossProjectPolicy;
+  routePath: string;
+  onError?: (error: Error, context: Context) => unknown | Promise<unknown>;
+  reportError?: (error: unknown) => void;
+}
+
+export const bindHonoRouteHandlers = ({
+  handler,
+  policy,
+  routePath,
+  onError,
+  reportError,
+}: BindHonoRouteHandlersOptions): MiddlewareHandler | MiddlewareHandler[] => {
+  const handlers = Array.isArray(handler) ? handler : [handler];
+  const [firstHandler, ...restHandlers] = handlers;
+  let routeHandlers: MiddlewareHandler | MiddlewareHandler[] = handler;
+
+  if (firstHandler) {
+    const errorBoundary: MiddlewareHandler = async (context, next) => {
+      try {
+        return await firstHandler(context, next);
+      } catch (error) {
+        try {
+          if (onError) {
+            const result = await onError(error as Error, context);
+            if (result instanceof Response) {
+              return result;
+            }
+          } else {
+            reportError?.(error);
+          }
+        } catch (configError) {
+          reportError?.(
+            `Error in serverConfig.onError handler: ${configError}`,
+          );
+        }
+
+        return createSafeFailureResponse(error);
+      }
+    };
+    routeHandlers = Array.isArray(handler)
+      ? [errorBoundary, ...restHandlers]
+      : errorBoundary;
+  }
+
+  if (!policy) {
+    return routeHandlers;
+  }
+
+  return [
+    createHonoCrossProjectPolicyMiddleware(policy, routePath),
+    ...(Array.isArray(routeHandlers) ? routeHandlers : [routeHandlers]),
+  ];
+};

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

@@ -0,0 +1,26 @@
+import type { MiddlewareHandler } from '@modern-js/server-core';
+
+import {
+  checkCrossProjectPolicyResponse,
+  type ResolvedCrossProjectPolicy,
+} from '../cross-project-policy/evaluation';
+
+export const createHonoCrossProjectPolicyMiddleware = (
+  policy: ResolvedCrossProjectPolicy,
+  routePath: string,
+): MiddlewareHandler =>
+  async function honoCrossProjectPolicyMiddleware(context, next) {
+    const denial = checkCrossProjectPolicyResponse(
+      context.req.header(),
+      policy,
+      {
+        method: context.req.method,
+        routePath,
+      },
+    );
+    if (denial) {
+      return denial;
+    }
+
+    return next();
+  };

package/src/hono/index.ts

@@ -0,0 +1,4 @@
+export {
+  type BindHonoRouteHandlersOptions,
+  bindHonoRouteHandlers,
+} from './bind-route-handlers';