@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/src/module-federation-config/exposes.ts

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { inspectModuleFederationConfigSource } from './inspect';
+import type { ModuleFederationConfigInspection } from './types';
+
+const moduleFederationConfigFile = 'module-federation.config.ts';
+
+/**
+ * Returns undefined when the app ships no Module Federation config, or when the
+ * config cannot be inspected statically, so callers keep their own expectation
+ * rather than inventing a surface path. `ultramodern mf-types` reports those
+ * configs separately, so staying quiet here never hides a broken config.
+ * Native deployment policy loads dynamic configs through Modern.js's loader.
+ */
+export function readModuleFederationConfigInspection(
+  workspaceRoot: string,
+  appDirectory: string,
+): ModuleFederationConfigInspection | undefined {
+  const configPath = path.join(
+    workspaceRoot,
+    appDirectory,
+    moduleFederationConfigFile,
+  );
+  if (!fs.existsSync(configPath)) {
+    return undefined;
+  }
+  try {
+    const source = fs.readFileSync(configPath, 'utf-8');
+    return inspectModuleFederationConfigSource(
+      source,
+      appDirectory,
+      path.join(appDirectory, moduleFederationConfigFile),
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+/** The literal source paths, independently of the complete expose-name list. */
+export function readModuleFederationExposePaths(
+  workspaceRoot: string,
+  appDirectory: string,
+): Record<string, string> | undefined {
+  return readModuleFederationConfigInspection(workspaceRoot, appDirectory)
+    ?.exposePaths;
+}

package/src/module-federation-config/index.ts

@@ -0,0 +1,22 @@
+export {
+  readModuleFederationConfigInspection,
+  readModuleFederationExposePaths,
+} from './exposes';
+export { inspectModuleFederationConfigSource } from './inspect';
+export {
+  parseArrayLiteral,
+  parseLiteralString,
+  parseObjectLiteral,
+} from './object-literal';
+export {
+  findCreateModuleFederationConfigObject,
+  findExportDefaultObject,
+  locateCreateModuleFederationConfigObject,
+  parseConfigModule,
+  parseStaticExpression,
+} from './syntax';
+export type {
+  LocatedObjectLiteral,
+  ModuleFederationConfigInspection,
+  ParsedObjectLiteral,
+} from './types';

package/src/module-federation-config/inspect.ts

@@ -0,0 +1,157 @@
+import {
+  parseArrayLiteral,
+  parseLiteralString,
+  parseObjectLiteral,
+} from './object-literal';
+import {
+  findCreateModuleFederationConfigObject,
+  findExportDefaultObject,
+  parseConfigModule,
+} from './syntax';
+import type { ModuleFederationConfigInspection } from './types';
+
+type ExtractedExposes = Pick<
+  ModuleFederationConfigInspection,
+  'exposePaths' | 'exposes'
+>;
+
+function extractExposes(
+  configPath: string,
+  value: string | undefined,
+): ExtractedExposes {
+  if (value === undefined) {
+    return { exposePaths: {}, exposes: [] };
+  }
+
+  const object = parseObjectLiteral(value);
+  if (object) {
+    if (object.hasSpread) {
+      throw new Error(
+        `Cannot statically extract Module Federation exposes from ${configPath}; use a literal exposes object without spreads.`,
+      );
+    }
+    const exposePaths: Record<string, string> = {};
+    for (const [expose, source] of object.properties) {
+      const exposePath = parseLiteralString(source);
+      if (exposePath !== undefined) {
+        exposePaths[expose] = exposePath;
+      }
+    }
+    return {
+      exposePaths,
+      exposes: Array.from(object.properties.keys()).sort(),
+    };
+  }
+
+  const array = parseArrayLiteral(value);
+  if (array) {
+    return { exposePaths: {}, exposes: array.sort() };
+  }
+
+  throw new Error(
+    `Cannot statically extract Module Federation exposes from ${configPath}; use a literal exposes object or string array.`,
+  );
+}
+
+function extractDtsSettings(
+  configPath: string,
+  value: string | undefined,
+  exposes: string[],
+): ModuleFederationConfigInspection['dts'] {
+  if (value === 'false') {
+    if (exposes.length > 0) {
+      throw new Error(
+        `Module Federation DTS cannot be disabled for exposed app ${configPath}.`,
+      );
+    }
+    return {};
+  }
+  if (value === undefined) {
+    return {};
+  }
+
+  const dts = parseObjectLiteral(value);
+  if (!dts || dts.hasSpread) {
+    throw new Error(
+      `Cannot statically extract Module Federation DTS settings from ${configPath}; use a literal dts object.`,
+    );
+  }
+
+  const generateTypes = parseObjectLiteral(dts.properties.get('generateTypes'));
+  if (generateTypes?.hasSpread) {
+    throw new Error(
+      `Cannot statically extract Module Federation generateTypes settings from ${configPath}; use a literal generateTypes object.`,
+    );
+  }
+
+  const compilerInstanceSource =
+    generateTypes?.properties.get('compilerInstance');
+  return {
+    compilerInstance:
+      parseLiteralString(compilerInstanceSource) ??
+      (compilerInstanceSource === 'tsgoCompilerInstance'
+        ? 'effect-tsgo'
+        : undefined),
+    tsConfigPath: parseLiteralString(dts.properties.get('tsConfigPath')),
+  };
+}
+
+function hasHostOnlyNoExposesDeclaration(source: string): boolean {
+  return (parseConfigModule(source).comments ?? []).some(comment =>
+    /@?ultramodern-mf\s*:?\s*(?:host-only|no-exposes)\b/iu.test(comment.value),
+  );
+}
+
+export function inspectModuleFederationConfigSource(
+  source: string,
+  appDir: string,
+  configPath: string,
+): ModuleFederationConfigInspection {
+  const configObject =
+    findCreateModuleFederationConfigObject(source) ??
+    findExportDefaultObject(source);
+
+  if (!configObject) {
+    throw new Error(
+      `Cannot statically inspect Module Federation config ${configPath}; export or pass a literal config object.`,
+    );
+  }
+
+  const properties = parseObjectLiteral(configObject);
+  if (!properties) {
+    throw new Error(
+      `Cannot statically inspect Module Federation config ${configPath}; expected a literal config object.`,
+    );
+  }
+
+  if (properties.hasSpread) {
+    throw new Error(
+      `Cannot statically inspect Module Federation config ${configPath}; top-level config spreads are not supported.`,
+    );
+  }
+
+  const { exposePaths, exposes } = extractExposes(
+    configPath,
+    properties.properties.get('exposes'),
+  );
+  const hostOnlyNoExposes = hasHostOnlyNoExposesDeclaration(source);
+
+  if (hostOnlyNoExposes && exposes.length > 0) {
+    throw new Error(
+      `Module Federation host-only/no-exposes declaration conflicts with actual exposes in ${configPath}.`,
+    );
+  }
+
+  return {
+    appDir,
+    configPath,
+    dts: extractDtsSettings(
+      configPath,
+      properties.properties.get('dts'),
+      exposes,
+    ),
+    exposePaths,
+    exposes,
+    hostOnlyNoExposes,
+  };
+}

package/src/module-federation-config/object-literal.ts

@@ -0,0 +1,76 @@
+import { parseStaticExpression } from './syntax';
+import type { ParsedObjectLiteral } from './types';
+
+export function parseLiteralString(
+  source: string | undefined,
+): string | undefined {
+  const node = parseStaticExpression(source);
+  if (node?.type === 'StringLiteral') return node.value;
+  if (node?.type === 'TemplateLiteral' && node.expressions.length === 0) {
+    return node.quasis[0]?.value.cooked ?? undefined;
+  }
+  return undefined;
+}
+
+export function parseObjectLiteral(
+  source: string | undefined,
+): ParsedObjectLiteral | undefined {
+  const node = parseStaticExpression(source);
+  if (source === undefined || node?.type !== 'ObjectExpression')
+    return undefined;
+  const properties = new Map<string, string>();
+  let hasSpread = false;
+  for (const property of node.properties) {
+    if (
+      property.type !== 'ObjectProperty' ||
+      property.computed ||
+      property.shorthand
+    ) {
+      hasSpread = true;
+      continue;
+    }
+    const key =
+      property.key.type === 'Identifier'
+        ? property.key.name
+        : property.key.type === 'StringLiteral'
+          ? property.key.value
+          : undefined;
+    const value = parseStaticExpression(
+      source.slice(property.value.start ?? 0, property.value.end ?? 0),
+    );
+    if (
+      key === undefined ||
+      properties.has(key) ||
+      !value ||
+      value.start == null ||
+      value.end == null
+    ) {
+      hasSpread = true;
+      continue;
+    }
+    const rawValue = source.slice(
+      property.value.start ?? 0,
+      property.value.end ?? 0,
+    );
+    properties.set(key, rawValue.slice(value.start, value.end));
+  }
+  return { hasSpread, properties };
+}
+
+export function parseArrayLiteral(
+  source: string | undefined,
+): string[] | undefined {
+  const node = parseStaticExpression(source);
+  if (source === undefined || node?.type !== 'ArrayExpression')
+    return undefined;
+  const values: string[] = [];
+  for (const element of node.elements) {
+    if (!element || element.type === 'SpreadElement') return undefined;
+    const value = parseLiteralString(
+      source.slice(element.start ?? 0, element.end ?? 0),
+    );
+    if (value === undefined) return undefined;
+    values.push(value);
+  }
+  return values;
+}

package/src/module-federation-config/syntax.ts

@@ -0,0 +1,212 @@
+import {
+  type Expression,
+  type File,
+  parse,
+  parseExpression,
+} from '@babel/parser';
+import type { LocatedObjectLiteral } from './types';
+
+type ConfigNode = Expression | File['program']['body'][number];
+
+function unwrapExpression(node: Expression): Expression {
+  while (
+    node.type === 'TSAsExpression' ||
+    node.type === 'TSSatisfiesExpression' ||
+    node.type === 'TSNonNullExpression' ||
+    node.type === 'TSTypeAssertion' ||
+    node.type === 'ParenthesizedExpression'
+  ) {
+    node = node.expression;
+  }
+  return node;
+}
+
+export function parseStaticExpression(
+  source: string | undefined,
+): Expression | undefined {
+  if (source === undefined) {
+    return undefined;
+  }
+  try {
+    return unwrapExpression(
+      parseExpression(source, { plugins: ['typescript'] }),
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+export function parseConfigModule(source: string) {
+  return parse(source, { sourceType: 'module', plugins: ['typescript'] });
+}
+
+function locateExportedConfig(
+  source: string,
+  factory: boolean,
+): LocatedObjectLiteral | undefined {
+  const module = parseConfigModule(source);
+  const constants = new Map<string, Expression>();
+  const bindingStarts = new Map<string, number | null | undefined>();
+  const resolvedBindings = new Set<string>();
+  const allowedReferences = new Set<number>();
+  const factories = new Set<string>();
+  const namespaces = new Set<string>();
+  const defaults: ConfigNode[] = [];
+
+  for (const statement of module.program.body) {
+    if (
+      statement.type === 'ImportDeclaration' &&
+      statement.importKind !== 'type' &&
+      statement.source.value === '@module-federation/modern-js-v3'
+    ) {
+      for (const specifier of statement.specifiers) {
+        if (specifier.type === 'ImportNamespaceSpecifier') {
+          namespaces.add(specifier.local.name);
+        } else if (
+          specifier.type === 'ImportSpecifier' &&
+          specifier.importKind !== 'type' &&
+          (specifier.imported.type === 'Identifier'
+            ? specifier.imported.name
+            : specifier.imported.value) === 'createModuleFederationConfig'
+        ) {
+          factories.add(specifier.local.name);
+        }
+      }
+    }
+    const declaration =
+      statement.type === 'ExportNamedDeclaration'
+        ? statement.declaration
+        : statement;
+    if (
+      declaration?.type === 'VariableDeclaration' &&
+      declaration.kind === 'const'
+    ) {
+      for (const binding of declaration.declarations) {
+        if (binding.id.type === 'Identifier' && binding.init) {
+          constants.set(binding.id.name, binding.init);
+          bindingStarts.set(binding.id.name, binding.id.start);
+        }
+      }
+    }
+    if (statement.type === 'ExportDefaultDeclaration') {
+      defaults.push(statement.declaration);
+    } else if (
+      statement.type === 'ExportNamedDeclaration' &&
+      !statement.source &&
+      statement.exportKind !== 'type'
+    ) {
+      for (const specifier of statement.specifiers) {
+        if (
+          specifier.type === 'ExportSpecifier' &&
+          specifier.exportKind !== 'type' &&
+          (specifier.exported.type === 'Identifier'
+            ? specifier.exported.name
+            : specifier.exported.value) === 'default'
+        ) {
+          defaults.push(specifier.local);
+        }
+      }
+    }
+  }
+
+  const resolve = (
+    node: ConfigNode | undefined,
+    seen = new Set<string>(),
+  ): ConfigNode | undefined => {
+    if (!node) return undefined;
+    if (node.type === 'Identifier') {
+      if (seen.has(node.name)) return undefined;
+      seen.add(node.name);
+      resolvedBindings.add(node.name);
+      if (node.start != null) allowedReferences.add(node.start);
+      const bindingStart = bindingStarts.get(node.name);
+      if (bindingStart != null) allowedReferences.add(bindingStart);
+      return resolve(constants.get(node.name), seen);
+    }
+    if (
+      node.type === 'TSAsExpression' ||
+      node.type === 'TSSatisfiesExpression' ||
+      node.type === 'TSNonNullExpression' ||
+      node.type === 'TSTypeAssertion' ||
+      node.type === 'ParenthesizedExpression'
+    ) {
+      return resolve(node.expression, seen);
+    }
+    return node;
+  };
+
+  if (defaults.length !== 1) return undefined;
+  let node = resolve(defaults[0]);
+  if (factory) {
+    if (node?.type !== 'CallExpression' || node.arguments.length !== 1)
+      return undefined;
+    const callee = node.callee;
+    const supported =
+      (callee.type === 'Identifier' && factories.has(callee.name)) ||
+      (callee.type === 'MemberExpression' &&
+        !callee.computed &&
+        callee.object.type === 'Identifier' &&
+        namespaces.has(callee.object.name) &&
+        callee.property.type === 'Identifier' &&
+        callee.property.name === 'createModuleFederationConfig');
+    if (!supported) return undefined;
+    const argument = node.arguments[0];
+    if (
+      !argument ||
+      argument.type === 'SpreadElement' ||
+      argument.type === 'ArgumentPlaceholder'
+    )
+      return undefined;
+    node = resolve(argument);
+  }
+  if (
+    node?.type !== 'ObjectExpression' ||
+    node.start == null ||
+    node.end == null
+  )
+    return undefined;
+  // A const object can still be mutated or passed to arbitrary code. Only
+  // references followed along the exported config chain are statically safe.
+  const hasOtherReference = (value: unknown): boolean => {
+    if (!value || typeof value !== 'object') return false;
+    if (Array.isArray(value)) return value.some(hasOtherReference);
+    const entry = value as Record<string, unknown>;
+    if (
+      entry.type === 'Identifier' &&
+      typeof entry.name === 'string' &&
+      resolvedBindings.has(entry.name) &&
+      (typeof entry.start !== 'number' || !allowedReferences.has(entry.start))
+    )
+      return true;
+    return Object.entries(entry).some(
+      ([key, child]) =>
+        key !== 'loc' &&
+        key !== 'comments' &&
+        key !== 'leadingComments' &&
+        key !== 'trailingComments' &&
+        hasOtherReference(child),
+    );
+  };
+  if (hasOtherReference(module.program)) return undefined;
+  return {
+    start: node.start,
+    end: node.end,
+    source: source.slice(node.start, node.end),
+  };
+}
+
+export function locateCreateModuleFederationConfigObject(
+  source: string,
+): LocatedObjectLiteral | undefined {
+  return locateExportedConfig(source, true);
+}
+
+export function findCreateModuleFederationConfigObject(
+  source: string,
+): string | undefined {
+  return locateCreateModuleFederationConfigObject(source)?.source;
+}
+
+export function findExportDefaultObject(source: string): string | undefined {
+  return locateExportedConfig(source, false)?.source;
+}

package/src/module-federation-config/types.ts

@@ -0,0 +1,22 @@
+export type ModuleFederationConfigInspection = {
+  appDir: string;
+  configPath: string;
+  dts: {
+    compilerInstance?: string;
+    tsConfigPath?: string;
+  };
+  exposePaths: Record<string, string>;
+  exposes: string[];
+  hostOnlyNoExposes: boolean;
+};
+
+export type LocatedObjectLiteral = {
+  end: number;
+  source: string;
+  start: number;
+};
+
+export type ParsedObjectLiteral = {
+  hasSpread: boolean;
+  properties: Map<string, string>;
+};