@beignet/cli 0.0.47 → 0.0.49

package/src/analysis/port-wiring.ts

@@ -0,0 +1,506 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import ts from "typescript";
+import type { ResolvedBeignetConfig } from "../config.js";
+import type { AnalysisWorkspace } from "./workspace.js";
+
+type PortAnalysisWorkspace = Pick<
+  AnalysisWorkspace,
+  "config" | "fileSet" | "readSourceFile"
+>;
+
+export type PortWiringAnalysis = {
+  portsFileExists: boolean;
+  portWiringFileExists: boolean;
+  properties: Map<string, ts.PropertySignature>;
+  declared: Set<string>;
+  bound: Set<string>;
+  deferred: Set<string>;
+  appPortsInferredFromWiring: boolean;
+  declarationIndeterminate: boolean;
+  indeterminate: boolean;
+};
+
+export async function analyzePortWiring(
+  workspace: PortAnalysisWorkspace,
+): Promise<PortWiringAnalysis> {
+  const result: PortWiringAnalysis = {
+    portsFileExists: workspace.fileSet.has(workspace.config.paths.ports),
+    portWiringFileExists: workspace.fileSet.has(
+      workspace.config.paths.portWiring,
+    ),
+    properties: new Map(),
+    declared: new Set(),
+    bound: new Set(),
+    deferred: new Set(),
+    appPortsInferredFromWiring: false,
+    declarationIndeterminate: false,
+    indeterminate: false,
+  };
+
+  let inferredAppPortsName: string | undefined;
+  if (result.portsFileExists) {
+    const sourceFile = await workspace.readSourceFile(
+      workspace.config.paths.ports,
+    );
+    const declarations = collectTypeDeclarations(sourceFile);
+    inferredAppPortsName = inferredTypeQueryName("AppPorts", declarations);
+    const collection = inferredAppPortsName
+      ? { properties: [], indeterminate: false }
+      : collectNamedTypeProperties("AppPorts", declarations, true);
+    result.declarationIndeterminate = collection.indeterminate;
+    for (const property of collection.properties) {
+      const name = propertyName(property.name);
+      if (name && !result.properties.has(name)) {
+        result.properties.set(name, property);
+        result.declared.add(name);
+      }
+    }
+  }
+
+  if (!result.portWiringFileExists) {
+    if (inferredAppPortsName) result.declarationIndeterminate = true;
+    return result;
+  }
+  const sourceFile = await workspace.readSourceFile(
+    workspace.config.paths.portWiring,
+  );
+  const values = collectVariableInitializers(sourceFile);
+  const definitions = portDefinitionCalls(sourceFile);
+  if (definitions.indeterminate) result.indeterminate = true;
+
+  for (const call of definitions.calls) {
+    const objectArgument = call.arguments
+      .map((argument) => resolveLocalExpression(argument, values))
+      .find(ts.isObjectLiteralExpression);
+    if (!objectArgument) {
+      if (call.arguments.length > 0) result.indeterminate = true;
+      continue;
+    }
+
+    const bound = objectPropertyAnalysis(objectArgument, "bound");
+    const deferred = objectPropertyAnalysis(objectArgument, "deferred");
+    if (
+      !bound.property &&
+      !bound.indeterminate &&
+      !deferred.property &&
+      !deferred.indeterminate
+    ) {
+      if (addObjectPropertyNames(objectArgument, result.bound)) {
+        result.indeterminate = true;
+      }
+      continue;
+    }
+    if (bound.indeterminate || deferred.indeterminate) {
+      result.indeterminate = true;
+    }
+
+    const boundValue = bound.property
+      ? resolveLocalExpression(propertyInitializer(bound.property), values)
+      : undefined;
+    if (boundValue && ts.isObjectLiteralExpression(boundValue)) {
+      if (addObjectPropertyNames(boundValue, result.bound)) {
+        result.indeterminate = true;
+      }
+    } else if (bound.property) {
+      result.indeterminate = true;
+    }
+
+    const deferredValue = deferred.property
+      ? resolveLocalExpression(propertyInitializer(deferred.property), values)
+      : undefined;
+    if (deferredValue && ts.isArrayLiteralExpression(deferredValue)) {
+      for (const element of deferredValue.elements) {
+        const value = literalText(resolveLocalExpression(element, values));
+        if (value) result.deferred.add(value);
+        else result.indeterminate = true;
+      }
+    } else if (deferred.property) {
+      result.indeterminate = true;
+    }
+  }
+
+  if (inferredAppPortsName) {
+    if (
+      !definitions.indeterminate &&
+      definitions.name === inferredAppPortsName
+    ) {
+      result.appPortsInferredFromWiring = true;
+      for (const name of result.bound) result.declared.add(name);
+      for (const name of result.deferred) result.declared.add(name);
+    } else {
+      result.declarationIndeterminate = true;
+    }
+  }
+
+  return result;
+}
+
+function portDefinitionCalls(sourceFile: ts.SourceFile): {
+  calls: ts.CallExpression[];
+  name?: string;
+  indeterminate: boolean;
+} {
+  const exportedNames = locallyExportedNames(sourceFile);
+  const candidates: {
+    name?: string;
+    exported: boolean;
+    calls: ts.CallExpression[];
+  }[] = [];
+
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    const statementExported = Boolean(
+      statement.modifiers?.some(
+        (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword,
+      ),
+    );
+    for (const declaration of statement.declarationList.declarations) {
+      if (!declaration.initializer) continue;
+      const calls = definePortsCalls(declaration.initializer);
+      if (calls.length === 0) continue;
+      const name = ts.isIdentifier(declaration.name)
+        ? declaration.name.text
+        : undefined;
+      candidates.push({
+        ...(name ? { name } : {}),
+        exported: statementExported || (name ? exportedNames.has(name) : false),
+        calls,
+      });
+    }
+  }
+
+  const canonical = candidates.filter(
+    (candidate) => candidate.name === "initialPorts" && candidate.exported,
+  );
+  const exported = candidates.filter((candidate) => candidate.exported);
+  const selected =
+    canonical.length > 0
+      ? canonical
+      : exported.length > 0
+        ? exported
+        : candidates;
+
+  if (selected.length === 1 && selected[0].calls.length === 1) {
+    return {
+      calls: selected[0].calls,
+      ...(selected[0].name ? { name: selected[0].name } : {}),
+      indeterminate: false,
+    };
+  }
+  if (selected.length > 0) return { calls: [], indeterminate: true };
+
+  const fallback = definePortsCalls(sourceFile);
+  return fallback.length === 1
+    ? { calls: fallback, indeterminate: false }
+    : { calls: [], indeterminate: fallback.length > 0 };
+}
+
+function locallyExportedNames(sourceFile: ts.SourceFile): Set<string> {
+  const names = new Set<string>();
+  for (const statement of sourceFile.statements) {
+    if (
+      !ts.isExportDeclaration(statement) ||
+      !statement.exportClause ||
+      !ts.isNamedExports(statement.exportClause) ||
+      statement.moduleSpecifier
+    ) {
+      continue;
+    }
+    for (const element of statement.exportClause.elements) {
+      names.add(element.propertyName?.text ?? element.name.text);
+    }
+  }
+  return names;
+}
+
+function definePortsCalls(node: ts.Node): ts.CallExpression[] {
+  const calls: ts.CallExpression[] = [];
+  visitCalls(node, (call) => {
+    if (callName(call) === "definePorts" && call.arguments.length > 0) {
+      calls.push(call);
+    }
+  });
+  return calls;
+}
+
+export async function analyzePortWiringFiles(options: {
+  targetDir: string;
+  files: readonly string[];
+  config: ResolvedBeignetConfig;
+}): Promise<PortWiringAnalysis> {
+  const sourceFiles = new Map<string, ts.SourceFile>();
+  return analyzePortWiring({
+    config: options.config,
+    fileSet: new Set(options.files),
+    async readSourceFile(file) {
+      const cached = sourceFiles.get(file);
+      if (cached) return cached;
+      const sourceFile = ts.createSourceFile(
+        file,
+        await readFile(path.join(options.targetDir, file), "utf8"),
+        ts.ScriptTarget.Latest,
+        true,
+        file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+      );
+      sourceFiles.set(file, sourceFile);
+      return sourceFile;
+    },
+  });
+}
+
+type TypeDeclaration = ts.TypeAliasDeclaration | ts.InterfaceDeclaration;
+type TypeDeclarations = Map<string, TypeDeclaration[]>;
+type PropertyCollection = {
+  properties: ts.PropertySignature[];
+  indeterminate: boolean;
+};
+
+function collectTypeDeclarations(sourceFile: ts.SourceFile): TypeDeclarations {
+  const declarations: TypeDeclarations = new Map();
+  for (const statement of sourceFile.statements) {
+    if (
+      ts.isTypeAliasDeclaration(statement) ||
+      ts.isInterfaceDeclaration(statement)
+    ) {
+      const name = statement.name.text;
+      declarations.set(name, [...(declarations.get(name) ?? []), statement]);
+    }
+  }
+  return declarations;
+}
+
+function collectNamedTypeProperties(
+  name: string,
+  declarations: TypeDeclarations,
+  root = false,
+  visited = new Set<string>(),
+): PropertyCollection {
+  if (visited.has(name)) return { properties: [], indeterminate: false };
+  visited.add(name);
+  const namedDeclarations = declarations.get(name);
+  if (!namedDeclarations) {
+    return { properties: [], indeterminate: !root };
+  }
+
+  const collection: PropertyCollection = {
+    properties: [],
+    indeterminate: false,
+  };
+  for (const declaration of namedDeclarations) {
+    if (ts.isInterfaceDeclaration(declaration)) {
+      collection.properties.push(
+        ...declaration.members.filter(ts.isPropertySignature),
+      );
+      for (const clause of declaration.heritageClauses ?? []) {
+        for (const type of clause.types) {
+          if (!ts.isIdentifier(type.expression)) {
+            collection.indeterminate = true;
+            continue;
+          }
+          const inherited = collectNamedTypeProperties(
+            type.expression.text,
+            declarations,
+            false,
+            visited,
+          );
+          collection.properties.push(...inherited.properties);
+          collection.indeterminate ||= inherited.indeterminate;
+        }
+      }
+      continue;
+    }
+
+    const aliased = collectTypeNodeProperties(
+      declaration.type,
+      declarations,
+      visited,
+    );
+    collection.properties.push(...aliased.properties);
+    collection.indeterminate ||= aliased.indeterminate;
+  }
+  return collection;
+}
+
+function collectTypeNodeProperties(
+  type: ts.TypeNode,
+  declarations: TypeDeclarations,
+  visited: Set<string>,
+): PropertyCollection {
+  if (ts.isTypeLiteralNode(type)) {
+    return {
+      properties: type.members.filter(ts.isPropertySignature),
+      indeterminate: false,
+    };
+  }
+  if (ts.isIntersectionTypeNode(type)) {
+    const members = type.types.map((member) =>
+      collectTypeNodeProperties(member, declarations, visited),
+    );
+    return {
+      properties: members.flatMap((member) => member.properties),
+      indeterminate: members.some((member) => member.indeterminate),
+    };
+  }
+  if (ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName)) {
+    return collectNamedTypeProperties(
+      type.typeName.text,
+      declarations,
+      false,
+      visited,
+    );
+  }
+  return { properties: [], indeterminate: true };
+}
+
+function inferredTypeQueryName(
+  name: string,
+  declarations: TypeDeclarations,
+): string | undefined {
+  const namedDeclarations = declarations.get(name);
+  if (
+    namedDeclarations?.length !== 1 ||
+    !ts.isTypeAliasDeclaration(namedDeclarations[0]) ||
+    !ts.isTypeQueryNode(namedDeclarations[0].type) ||
+    !ts.isIdentifier(namedDeclarations[0].type.exprName)
+  ) {
+    return undefined;
+  }
+  return namedDeclarations[0].type.exprName.text;
+}
+
+function collectVariableInitializers(
+  sourceFile: ts.SourceFile,
+): Map<string, ts.Expression> {
+  const values = new Map<string, ts.Expression>();
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts.isIdentifier(declaration.name) && declaration.initializer) {
+        values.set(declaration.name.text, declaration.initializer);
+      }
+    }
+  }
+  return values;
+}
+
+function resolveLocalExpression(
+  expression: ts.Expression,
+  values: Map<string, ts.Expression>,
+  visited = new Set<string>(),
+): ts.Expression {
+  const current = unwrapExpression(expression);
+  if (!ts.isIdentifier(current) || visited.has(current.text)) return current;
+  const target = values.get(current.text);
+  if (!target) return current;
+  visited.add(current.text);
+  return resolveLocalExpression(target, values, visited);
+}
+
+function unwrapExpression(expression: ts.Expression): ts.Expression {
+  let current = expression;
+  while (
+    ts.isParenthesizedExpression(current) ||
+    ts.isAsExpression(current) ||
+    ts.isSatisfiesExpression(current) ||
+    ts.isTypeAssertionExpression(current) ||
+    ts.isNonNullExpression(current)
+  ) {
+    current = current.expression;
+  }
+  return current;
+}
+
+function addObjectPropertyNames(
+  object: ts.ObjectLiteralExpression,
+  target: Set<string>,
+): boolean {
+  let indeterminate = false;
+  for (const property of object.properties) {
+    if (ts.isSpreadAssignment(property)) {
+      target.clear();
+      indeterminate = true;
+      continue;
+    }
+    const name = property.name ? propertyName(property.name) : undefined;
+    if (name) target.add(name);
+    else {
+      target.clear();
+      indeterminate = true;
+    }
+  }
+  return indeterminate;
+}
+
+function objectPropertyAnalysis(
+  object: ts.ObjectLiteralExpression,
+  name: string,
+): {
+  property?: ts.PropertyAssignment | ts.ShorthandPropertyAssignment;
+  indeterminate: boolean;
+} {
+  let property:
+    | ts.PropertyAssignment
+    | ts.ShorthandPropertyAssignment
+    | undefined;
+  let indeterminate = false;
+  for (const member of object.properties) {
+    if (ts.isSpreadAssignment(member) || !member.name) {
+      property = undefined;
+      indeterminate = true;
+      continue;
+    }
+    const key = propertyName(member.name);
+    if (!key) {
+      property = undefined;
+      indeterminate = true;
+      continue;
+    }
+    if (key !== name) continue;
+    if (
+      ts.isPropertyAssignment(member) ||
+      ts.isShorthandPropertyAssignment(member)
+    ) {
+      property = member;
+      indeterminate = false;
+    } else {
+      property = undefined;
+      indeterminate = true;
+    }
+  }
+  return { ...(property ? { property } : {}), indeterminate };
+}
+
+function propertyInitializer(
+  property: ts.PropertyAssignment | ts.ShorthandPropertyAssignment,
+): ts.Expression {
+  return ts.isPropertyAssignment(property)
+    ? property.initializer
+    : property.name;
+}
+
+function callName(call: ts.CallExpression): string | undefined {
+  const expression = call.expression;
+  if (ts.isIdentifier(expression)) return expression.text;
+  if (ts.isPropertyAccessExpression(expression)) return expression.name.text;
+  if (ts.isCallExpression(expression)) return callName(expression);
+  return undefined;
+}
+
+function visitCalls(node: ts.Node, visit: (call: ts.CallExpression) => void) {
+  const walker = (child: ts.Node): void => {
+    if (ts.isCallExpression(child)) visit(child);
+    ts.forEachChild(child, walker);
+  };
+  walker(node);
+}
+
+function propertyName(name: ts.PropertyName): string | undefined {
+  if (ts.isIdentifier(name) || ts.isStringLiteralLike(name)) return name.text;
+  return undefined;
+}
+
+function literalText(expression: ts.Expression): string | undefined {
+  if (ts.isStringLiteralLike(expression)) return expression.text;
+  return undefined;
+}