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

package/src/cross-project.ts

@@ -0,0 +1,72 @@
+import '@modern-js/server-runtime-extensions/server-config';
+import path from 'node:path';
+import {
+  type CrossProjectApiPluginOptions,
+  createCrossProjectApiPlugin,
+} from '@modern-js/plugin-bff/cross-project';
+import type { OperationContractMap } from '@modern-js/server-runtime-extensions/bff-policy/node';
+
+export interface CrossProjectBffDescriptor {
+  native: Omit<CrossProjectApiPluginOptions, 'modifyResolvedConfig'>;
+  runtimeFramework: 'hono' | 'effect';
+  relativeEffectEntry: string;
+  requestId: string;
+  operationContracts: OperationContractMap;
+}
+
+export function createCrossProjectBffPlugin(
+  descriptor: CrossProjectBffDescriptor,
+) {
+  return createCrossProjectApiPlugin({
+    ...descriptor.native,
+    modifyResolvedConfig: (resolvedConfig, { sdkDistDirectory, api }) => {
+      const config = api.getConfig();
+      const configuredRuntimeFramework = config?.bff?.runtimeFramework;
+      if (
+        configuredRuntimeFramework &&
+        configuredRuntimeFramework !== descriptor.runtimeFramework
+      ) {
+        throw new Error(
+          `[${descriptor.native.packageName}] Runtime framework mismatch for cross-project BFF. Detected "${configuredRuntimeFramework}", but producer SDK requires "${descriptor.runtimeFramework}".`,
+        );
+      }
+      const effectEntry = descriptor.relativeEffectEntry
+        ? path.join(sdkDistDirectory, descriptor.relativeEffectEntry)
+        : undefined;
+      api.updateAppContext({
+        ...(effectEntry ? { apiDirectory: path.dirname(effectEntry) } : {}),
+        bffRuntimeFramework: descriptor.runtimeFramework,
+      });
+      resolvedConfig.bff ??= {};
+      resolvedConfig.bff.runtimeFramework = descriptor.runtimeFramework;
+      if (effectEntry)
+        resolvedConfig.bff.effect = {
+          ...resolvedConfig.bff.effect,
+          entry: effectEntry,
+        };
+      resolvedConfig.bff.requestId =
+        resolvedConfig.bff.requestId ||
+        config?.bff?.requestId ||
+        descriptor.requestId ||
+        descriptor.native.packageName ||
+        'default';
+      const policy = resolvedConfig.bff.crossProjectPolicy;
+      resolvedConfig.bff.crossProjectPolicy = {
+        ...policy,
+        enabled: policy?.enabled ?? true,
+        requireEnvelope: policy?.requireEnvelope ?? true,
+        requireOperationContext: policy?.requireOperationContext ?? true,
+        requireOperationContextDetails:
+          policy?.requireOperationContextDetails ?? true,
+        requireOperationSchemaHash: policy?.requireOperationSchemaHash ?? true,
+        requireOperationVersion: policy?.requireOperationVersion ?? true,
+        allowUnknownOperations: policy?.allowUnknownOperations ?? false,
+        expectedOperationContracts: {
+          ...policy?.expectedOperationContracts,
+          ...descriptor.operationContracts,
+        },
+      };
+      return resolvedConfig;
+    },
+  });
+}

package/src/generated-entries.ts

@@ -0,0 +1,100 @@
+import { pathToFileURL } from 'node:url';
+import type {
+  AppTools,
+  BffGeneratedEntries,
+  BffGeneration,
+} from '@modern-js/app-tools';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import { fs, upath as path } from '@modern-js/utils';
+import {
+  BFF_REQUEST_RUNTIME,
+  type BffGenerationMetadata,
+} from './client-artifacts';
+import type { CrossProjectBffDescriptor } from './cross-project';
+
+export function registerBffGeneratedEntries(
+  api: CLIPluginAPI<AppTools>,
+  metadata: WeakMap<BffGeneration, BffGenerationMetadata>,
+) {
+  api.modifyBffGeneratedEntries(async (entries: BffGeneratedEntries) => {
+    const { generation } = entries;
+    const details = metadata.get(generation);
+    if (!details)
+      throw new Error(
+        'BFF entries require completed client artifact generation.',
+      );
+    metadata.delete(generation);
+    const packageJson = await fs.readJSON(
+      path.join(generation.appDirectory, 'package.json'),
+    );
+    const runtimeSpecifier =
+      api.getNormalizedConfig().bff?.runtimeCreateRequest ||
+      BFF_REQUEST_RUNTIME;
+    const dependencies = [
+      '@modern-js/plugin-bff-build-extensions',
+      '@modern-js/plugin-bff-extensions',
+    ];
+    const emitsClient =
+      details.runtimeFramework === 'effect' || generation.apiFiles.length > 0;
+    if (
+      runtimeSpecifier === BFF_REQUEST_RUNTIME ||
+      (emitsClient &&
+        (generation.requestCreator || BFF_REQUEST_RUNTIME) ===
+          BFF_REQUEST_RUNTIME)
+    )
+      dependencies.push('@modern-js/runtime-extensions');
+    for (const name of dependencies) {
+      const specifier =
+        packageJson.dependencies?.[name] ||
+        packageJson.devDependencies?.[name] ||
+        fs.readJSONSync(require.resolve(`${name}/package.json`)).version;
+      entries.packageDependencies[name] = specifier;
+    }
+    const descriptor: CrossProjectBffDescriptor = {
+      native: {
+        packageName: packageJson.name,
+        prefix: generation.prefix,
+        relativeDistPath: path.normalize(generation.relativeDistPath),
+        relativeApiPath: path.relative(
+          generation.appDirectory,
+          generation.apiDirectory,
+        ),
+        relativeLambdaPath: path.relative(
+          generation.appDirectory,
+          generation.lambdaDirectory,
+        ),
+      },
+      runtimeFramework: details.runtimeFramework,
+      relativeEffectEntry: details.relativeEffectEntry,
+      requestId: generation.requestId,
+      operationContracts: details.operationContracts,
+    };
+    const isModule =
+      api.getAppContext().moduleType === 'module' ||
+      packageJson.type === 'module';
+    entries.plugin = {
+      code: isModule
+        ? `import { createCrossProjectBffPlugin } from '@modern-js/plugin-bff-build-extensions/cross-project';\nexport const crossProjectApiPlugin = () => createCrossProjectBffPlugin(${JSON.stringify(descriptor)});\n`
+        : `'use strict';\nconst { createCrossProjectBffPlugin } = require('@modern-js/plugin-bff-build-extensions/cross-project');\nexports.crossProjectApiPlugin = () => createCrossProjectBffPlugin(${JSON.stringify(descriptor)});\n`,
+      declaration: `import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+export declare const crossProjectApiPlugin: () => CliPlugin<AppTools>;
+`,
+    };
+    const runtime = JSON.stringify(runtimeSpecifier);
+    const esmRuntime = JSON.stringify(
+      path.isAbsolute(runtimeSpecifier)
+        ? pathToFileURL(runtimeSpecifier).href
+        : runtimeSpecifier,
+    );
+    entries.runtime = {
+      code: isModule
+        ? `import { configure as _configure } from ${esmRuntime};\nimport { createProducerClient } from '@modern-js/plugin-bff-extensions/producer-runtime';\nexport const configure = createProducerClient(_configure, { requestId: ${JSON.stringify(generation.requestId)} });\nexport const initProducerClient = configure;\n`
+        : `'use strict';\nconst { configure: _configure } = require(${runtime});\nconst { createProducerClient } = require('@modern-js/plugin-bff-extensions/producer-runtime');\nconst configure = createProducerClient(_configure, { requestId: ${JSON.stringify(generation.requestId)} });\nexports.configure = configure;\nexports.initProducerClient = configure;\n`,
+      declaration: `type Runtime = typeof import(${runtime});
+export declare const initProducerClient: (options?: Parameters<Runtime['configure']>[0]) => ReturnType<Runtime['configure']>;
+export declare const configure: typeof initProducerClient;
+`,
+    };
+    return entries;
+  });
+}

package/src/hono-client-codegen.ts

@@ -0,0 +1,83 @@
+import path from 'node:path';
+import type { ClientCodegenPlugin } from '@modern-js/bff-core';
+import {
+  buildOperationContractMap,
+  createOperationSchemaHash,
+  deriveOperationVersion,
+} from '@modern-js/server-runtime-extensions/bff-policy/node';
+
+const REQUEST_RUNTIME = '@modern-js/runtime-extensions/request-policy';
+
+export const modifyClient: ClientCodegenPlugin = (draft, context) => {
+  const { appDir, requestId } = context.options;
+  draft.requestCreator = context.options.requestCreator || REQUEST_RUNTIME;
+  let version: string | undefined;
+  try {
+    version = require(path.resolve(appDir, 'package.json')).version;
+  } catch {
+    // Missing or invalid package metadata uses the established version fallback.
+  }
+  const operationVersion = deriveOperationVersion(version);
+  const normalizedRequestId = requestId || 'default';
+  const operationContracts = buildOperationContractMap({
+    handlers: [...context.handlerInfos],
+    requestId: normalizedRequestId,
+    operationVersion,
+  });
+  const operationEntries = context.handlerInfos
+    .map(handlerInfo => {
+      const httpMethod = handlerInfo.httpMethod.toUpperCase();
+      return {
+        name: handlerInfo.name,
+        httpMethod,
+        routePath: handlerInfo.routePath,
+        schemaHash:
+          operationContracts[`${httpMethod}:${handlerInfo.routePath}`]
+            ?.schemaHash ?? '',
+      };
+    })
+    .sort((a, b) =>
+      `${a.routePath}:${a.httpMethod}:${a.name}`.localeCompare(
+        `${b.routePath}:${b.httpMethod}:${b.name}`,
+      ),
+    );
+  const schemaHash = createOperationSchemaHash(
+    operationEntries,
+    normalizedRequestId,
+  );
+  for (const { handlerInfo, optionProperties } of draft.handlers) {
+    if (handlerInfo.action === 'upload' && !requestId) continue;
+    const method = handlerInfo.httpMethod.toUpperCase();
+    const operationContext = {
+      operationId: handlerInfo.name,
+      routePath: handlerInfo.routePath,
+      method,
+      schemaHash:
+        operationContracts[`${method}:${handlerInfo.routePath}`]?.schemaHash ??
+        '',
+      operationVersion,
+    };
+    optionProperties.push(
+      `operationContext: ${JSON.stringify(operationContext)}`,
+    );
+  }
+  if (requestId) {
+    draft.imports.push(
+      `import * as requestRuntime from ${JSON.stringify(draft.requestCreator)};`,
+      'import { createProducerClient } from "@modern-js/plugin-bff-extensions/producer-runtime";',
+    );
+    draft.statements.push(`export const initProducerClient = (options = {}) => {
+  const configure = requestRuntime.configure;
+  if (typeof configure !== 'function') {
+    console.warn('[modernjs] Compatibility request creator path does not expose configure(); use default @modern-js/create-request or migrate the compatibility path.');
+    return undefined;
+  }
+  return createProducerClient(configure, { requestId: ${JSON.stringify(requestId)} })(options);
+};`);
+  }
+  draft.statements.push(
+    `export const operationVersion = ${String(operationVersion)};`,
+    `export const operationSchemaHash = ${JSON.stringify(schemaHash)};`,
+    `export const operationManifest = ${JSON.stringify({ operationVersion, schemaHash, operations: operationEntries }, null, 2)};`,
+  );
+};

package/src/index.ts

@@ -0,0 +1,131 @@
+import '@modern-js/server-runtime-extensions/server-config';
+import type { AppTools, BffGeneration, CliPlugin } from '@modern-js/app-tools';
+import { bffPlugin as nativeBffPlugin } from '@modern-js/plugin-bff';
+import { fs, upath as path } from '@modern-js/utils';
+import {
+  BFF_REQUEST_RUNTIME,
+  type BffGenerationMetadata,
+  registerBffClientArtifacts,
+} from './client-artifacts';
+import { registerBffCompilation } from './compile';
+import { registerBffGeneratedEntries } from './generated-entries';
+
+export const bffPlugin = (): CliPlugin<AppTools> => ({
+  name: '@modern-js/plugin-bff-build-extensions',
+  usePlugins: [nativeBffPlugin()],
+  pre: ['@modern-js/plugin-bff'],
+  setup: api => {
+    const hooks = api.getHooks();
+    for (const name of [
+      'onBeforeBffCompile',
+      'onAfterBffCompile',
+      'modifyBffClientArtifacts',
+      'modifyBffGeneratedEntries',
+    ] as const) {
+      if (typeof hooks[name]?.tap !== 'function')
+        throw new Error(`Native BFF build hook ${name} is unavailable.`);
+    }
+    api.config(() => ({
+      bff: {
+        requestCreator: BFF_REQUEST_RUNTIME,
+        runtimeCreateRequest: BFF_REQUEST_RUNTIME,
+        clientCodegenPlugin: require.resolve(
+          '@modern-js/plugin-bff-build-extensions/hono-client-codegen',
+        ),
+      },
+    }));
+    const runtimeFramework = api.getConfig()?.bff?.runtimeFramework;
+    if (
+      runtimeFramework !== undefined &&
+      runtimeFramework !== 'hono' &&
+      runtimeFramework !== 'effect'
+    ) {
+      throw new Error(`Unsupported Effect BFF runtime "${runtimeFramework}".`);
+    }
+    api.updateAppContext({ bffRuntimeFramework: runtimeFramework ?? 'effect' });
+    api._internalServerPlugins(({ plugins }) => {
+      const nativePlugins = plugins.filter(
+        plugin => plugin.name === '@modern-js/plugin-bff/server-plugin',
+      );
+      if (nativePlugins.length !== 1) {
+        throw new Error('Expected exactly one native BFF server plugin.');
+      }
+      const native = nativePlugins[0]!;
+      const runtimeAdapters = native.options?.runtimeAdapters ?? {};
+      const effect = '@modern-js/plugin-bff-extensions/effect-adapter';
+      const honoRouteBinder = '@modern-js/plugin-bff-extensions/hono/node';
+      if (
+        native.options?.honoRouteBinder !== undefined &&
+        native.options.honoRouteBinder !== honoRouteBinder
+      ) {
+        throw new Error('The Hono BFF route binder is already configured.');
+      }
+      if (
+        runtimeAdapters.effect !== undefined &&
+        runtimeAdapters.effect !== effect
+      ) {
+        throw new Error(
+          'The Effect BFF runtime adapter is already configured.',
+        );
+      }
+      native.options = {
+        ...native.options,
+        honoRouteBinder,
+        runtimeAdapters: { ...runtimeAdapters, effect },
+      };
+      return { plugins };
+    });
+    const metadata = new WeakMap<BffGeneration, BffGenerationMetadata>();
+    registerBffCompilation(api);
+    registerBffClientArtifacts(api, metadata);
+    registerBffGeneratedEntries(api, metadata);
+    api.modifyBundlerChain(async (chain, { isServer, CHAIN_ID }) => {
+      if (api.getAppContext().bffRuntimeFramework !== 'effect') return;
+      const { appDirectory, apiDirectory, port } = api.getAppContext();
+      const bff = api.getNormalizedConfig().bff;
+      const { resolveEffectEntryFile } = await import(
+        '@modern-js/plugin-bff-extensions/client-generator'
+      );
+      const entry = resolveEffectEntryFile({
+        appDir: appDirectory,
+        apiDir: apiDirectory,
+        effectEntry: bff?.effect?.entry,
+      });
+      if (!entry)
+        throw new Error(`Cannot resolve Effect BFF entry in ${apiDirectory}.`);
+      const canonical = (file: string) =>
+        path.normalize(
+          fs.existsSync(file) ? fs.realpathSync(file) : path.resolve(file),
+        );
+      const entryPath = canonical(entry);
+      const isEntry = (resource: string) => canonical(resource) === entryPath;
+      chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(isEntry);
+      chain.module.rule('js-bff-api').exclude.add(isEntry);
+      chain.module
+        .rule('js-bff-effect-entry')
+        .test(isEntry)
+        .use('effect-bff-loader')
+        .loader(
+          require.resolve(
+            '@modern-js/plugin-bff-extensions/effect-source-loader/rspack-loader',
+          ),
+        )
+        .options({
+          appDir: appDirectory,
+          apiDir: apiDirectory,
+          effectEntry: entry,
+          prefix: Array.isArray(bff?.prefix)
+            ? bff.prefix[0]
+            : bff?.prefix || '/api',
+          port,
+          target: isServer ? 'server' : 'client',
+          requestId: bff?.requestId,
+          requestCreator: bff?.requestCreator || BFF_REQUEST_RUNTIME,
+          httpMethodDecider: bff?.httpMethodDecider,
+          effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch,
+        });
+    });
+  },
+});
+
+export default bffPlugin;

package/src/server-global-vars.ts

@@ -0,0 +1,145 @@
+import type { AppTools } from '@modern-js/app-tools';
+import type { RsbuildTarget } from '@modern-js/builder';
+import { applyOptionsChain, fs, upath as path } from '@modern-js/utils';
+import { transform } from '@swc/core';
+
+type SerializedGlobalVars = Record<string, string>;
+type ServerGlobalVarsOptions = NonNullable<
+  NonNullable<AppTools['config']>['source']
+>['globalVars'];
+
+const RELEASE_IDENTITY_GLOBAL_NAMES = [
+  'ULTRAMODERN_BUILD_MARKER',
+  'ULTRAMODERN_SOURCE_REVISION',
+  'ULTRAMODERN_RELEASE_VERSION',
+] as const;
+
+const collectJavaScriptFiles = (directory: string): Promise<string[]> =>
+  Promise.resolve()
+    .then(() => fs.readdir(directory, { withFileTypes: true }))
+    .then(entries =>
+      Promise.all(
+        entries.map(entry => {
+          const absolutePath = path.join(directory, entry.name);
+          if (entry.isDirectory()) {
+            return collectJavaScriptFiles(absolutePath);
+          }
+          return /\.(?:c|m)?js$/u.test(entry.name) ? [absolutePath] : [];
+        }),
+      ).then(nested => nested.flat()),
+    );
+
+export const serializeServerGlobalVars = (
+  options: ServerGlobalVarsOptions,
+): SerializedGlobalVars => {
+  const globalVars = applyOptionsChain<
+    Record<string, unknown>,
+    { env: string; target: RsbuildTarget }
+  >({}, options, {
+    env: 'server',
+    target: 'node',
+  });
+
+  return Object.fromEntries(
+    Object.entries(globalVars).map(([key, value]) => {
+      let serialized: string | undefined;
+      try {
+        serialized = JSON.stringify(value);
+      } catch (error) {
+        throw new Error(
+          `source.globalVars["${key}"] cannot be serialized exactly for BFF compilation.`,
+          { cause: error },
+        );
+      }
+      if (serialized === undefined) {
+        throw new Error(
+          `source.globalVars["${key}"] cannot be serialized exactly for BFF compilation.`,
+        );
+      }
+      return [key, serialized];
+    }),
+  );
+};
+
+export const transformServerGlobalVars = (
+  outputDirectories: string[],
+  globalVars: SerializedGlobalVars,
+) =>
+  Promise.resolve().then(() => {
+    if (Object.keys(globalVars).length === 0) {
+      return undefined;
+    }
+
+    return Promise.all(
+      outputDirectories.map(directory =>
+        fs
+          .pathExists(directory)
+          .then(directoryExists => (directoryExists ? directory : undefined)),
+      ),
+    )
+      .then(existingDirectories => {
+        const filesPromise = Promise.all(
+          existingDirectories
+            .filter((directory): directory is string => directory !== undefined)
+            .map(collectJavaScriptFiles),
+        ).then(files => files.flat());
+
+        const releaseIdentityBanner = RELEASE_IDENTITY_GLOBAL_NAMES.every(
+          name => Object.hasOwn(globalVars, name),
+        )
+          ? `${RELEASE_IDENTITY_GLOBAL_NAMES.map(name => `void ${globalVars[name]};`).join('')}\n`
+          : '';
+
+        return filesPromise.then(files =>
+          Promise.all(
+            files.map(filename =>
+              fs.readFile(filename, 'utf8').then(source => {
+                const sourceMapFilename = `${filename}.map`;
+                return fs
+                  .pathExists(sourceMapFilename)
+                  .then(sourceMapExists => {
+                    const inputSourceMapPromise: Promise<string | undefined> =
+                      sourceMapExists
+                        ? fs.readFile(sourceMapFilename, 'utf8')
+                        : Promise.resolve(undefined);
+
+                    return inputSourceMapPromise.then(inputSourceMap =>
+                      transform(`${releaseIdentityBanner}${source}`, {
+                        filename,
+                        inputSourceMap,
+                        sourceMaps: sourceMapExists,
+                        jsc: {
+                          parser: {
+                            syntax: 'ecmascript',
+                          },
+                          preserveAllComments: true,
+                          target: 'es2024',
+                          transform: {
+                            optimizer: {
+                              globals: {
+                                vars: globalVars,
+                              },
+                            },
+                          },
+                        },
+                      }).then(result =>
+                        fs.writeFile(filename, result.code).then(() => {
+                          if (
+                            sourceMapExists &&
+                            result.map !== undefined &&
+                            result.map.length > 0
+                          ) {
+                            return fs.writeFile(sourceMapFilename, result.map);
+                          }
+                          return undefined;
+                        }),
+                      ),
+                    );
+                  });
+              }),
+            ),
+          ),
+        );
+      })
+      .then(() => undefined);
+  });

package/README.md

@@ -1,3 +0,0 @@
-# @bleedingdev/modern-js-plugin-bff-build-extensions
-
-This 0.0.0 version only registers the package name so npm trusted publishing can be configured. It contains no runtime implementation. Use the subsequent UltraModern.js release, published from the repository workflow with provenance.