@beignet/cli 0.0.48 → 0.0.49

package/src/app-map.ts

@@ -1,5 +1,11 @@
 import path from "node:path";
 import ts from "typescript";
+import {
+  contractBindingNames,
+  contractFactoryBindings,
+  isImportedContractDeclaration,
+} from "./analysis/contract-factories.js";
+import { analyzePortWiring } from "./analysis/port-wiring.js";
 import {
   createSourceIndex,
   exportedVariableDeclarations,
@@ -175,6 +181,12 @@ type RegistryRecord = {
   file: string;
   declaration: ts.VariableDeclaration;
   values: ts.Expression[];
+  outbox?: {
+    events: ts.Expression[];
+    jobs: ts.Expression[];
+    eventsIndeterminate: boolean;
+    jobsIndeterminate: boolean;
+  };
 };
 
 /** Build a deterministic, side-effect-free map of one Beignet app. */
@@ -474,6 +486,20 @@ export async function mapApp(
       if (registry) {
         addNode(registry.node);
         registries.push(registry);
+        if (registry.outbox?.eventsIndeterminate) {
+          unresolved.push({
+            code: "outbox_events_unresolved",
+            message: `Could not resolve the events entries for outbox registry ${exportName}.`,
+            source: registry.node.source,
+          });
+        }
+        if (registry.outbox?.jobsIndeterminate) {
+          unresolved.push({
+            code: "outbox_jobs_unresolved",
+            message: `Could not resolve the jobs entries for outbox registry ${exportName}.`,
+            source: registry.node.source,
+          });
+        }
       }
     }
   }
@@ -651,6 +677,18 @@ export async function mapApp(
     sourceIndex,
     addNode,
     addEdge,
+    unresolved,
+  });
+
+  await addOutboxDeliveryGraph({
+    workspace,
+    sourceIndex,
+    registries,
+    nodes,
+    edges,
+    addNode,
+    addEdge,
+    unresolved,
   });
 
   await addTables({ workspace, sourceIndex, addNode });
@@ -1021,54 +1059,62 @@ async function addPorts(args: {
   sourceIndex: ReturnType<typeof createSourceIndex>;
   addNode(node: AppMapNode): void;
   addEdge(edge: AppMapEdge): void;
+  unresolved: AppMapUnresolvedReference[];
 }): Promise<void> {
   const portsFile = args.workspace.config.paths.ports;
   if (!args.workspace.fileSet.has(portsFile)) return;
   const sourceFile = await args.workspace.readSourceFile(portsFile);
-  const aliases = new Map<string, ts.TypeNode>();
-  for (const statement of sourceFile.statements) {
-    if (ts.isTypeAliasDeclaration(statement)) {
-      aliases.set(statement.name.text, statement.type);
-    }
+  const analysis = await analyzePortWiring(args.workspace);
+  if (analysis.declarationIndeterminate) {
+    args.unresolved.push({
+      code: "app_ports_declaration_unresolved",
+      message: `Could not fully resolve AppPorts in ${portsFile}.`,
+      source: { file: portsFile },
+    });
   }
-  const appPorts = aliases.get("AppPorts");
-  if (!appPorts) return;
-
-  const bindings = await readPortBindings(args.workspace);
-  const properties = collectTypeProperties(appPorts, aliases);
-  for (const property of properties) {
-    const name = propertyName(property.name);
-    if (!name) continue;
-    const feature = await portFeature(
-      property.type,
-      portsFile,
-      args.workspace.config.paths.features,
-      args.sourceIndex,
-    );
+  if (analysis.indeterminate) {
+    args.unresolved.push({
+      code: "port_wiring_unresolved",
+      message: `Could not fully resolve port bindings in ${args.workspace.config.paths.portWiring}.`,
+      source: { file: args.workspace.config.paths.portWiring },
+    });
+  }
+  for (const name of analysis.declared) {
+    const property = analysis.properties.get(name);
+    const feature = property
+      ? await portFeature(
+          property.type,
+          portsFile,
+          args.workspace.config.paths.features,
+          args.sourceIndex,
+        )
+      : undefined;
     const id = portId(name);
     args.addNode({
       id,
       kind: "port",
       name,
       ...(feature ? { feature } : {}),
-      source: await args.sourceIndex.sourceLocation(portsFile, property),
+      source: property
+        ? await args.sourceIndex.sourceLocation(portsFile, property)
+        : { file: args.workspace.config.paths.portWiring },
       status:
-        bindings.bound.has(name) || bindings.deferred.has(name)
+        analysis.bound.has(name) || analysis.deferred.has(name)
           ? "registered"
           : "missing",
       details: {
-        binding: bindings.bound.has(name)
+        binding: analysis.bound.has(name)
           ? "bound"
-          : bindings.deferred.has(name)
+          : analysis.deferred.has(name)
             ? "deferred"
             : "unresolved",
-        type: property.type?.getText(sourceFile),
+        ...(property?.type ? { type: property.type.getText(sourceFile) } : {}),
       },
     });
     if (feature) {
       args.addEdge(exactEdge("owns", featureId(feature), id, portsFile));
     }
-    if (bindings.bound.has(name)) {
+    if (analysis.bound.has(name)) {
       const bindingId = `provider:app:${name}`;
       args.addNode({
         id: bindingId,
@@ -1090,6 +1136,182 @@ async function addPorts(args: {
   }
 }
 
+async function addOutboxDeliveryGraph(args: {
+  workspace: AnalysisWorkspace;
+  sourceIndex: ReturnType<typeof createSourceIndex>;
+  registries: RegistryRecord[];
+  nodes: Map<string, AppMapNode>;
+  edges: AppMapEdge[];
+  addNode(node: AppMapNode): void;
+  addEdge(edge: AppMapEdge): void;
+  unresolved: AppMapUnresolvedReference[];
+}): Promise<void> {
+  const outboxRegistries = args.registries.filter(
+    (registry) => registry.outbox !== undefined,
+  );
+  if (outboxRegistries.length === 0) return;
+  const jobRegistries = outboxRegistries.filter(
+    (registry) => registry.outbox && registry.outbox.jobs.length > 0,
+  );
+
+  const jobsPortId = portId("jobs");
+  if (jobRegistries.length > 0 && !args.nodes.has(jobsPortId)) {
+    args.addNode({
+      id: jobsPortId,
+      kind: "port",
+      name: "jobs",
+      source: { file: args.workspace.config.paths.ports },
+      status: "missing",
+      details: {
+        binding: "unresolved",
+        requiredBy: "outbox-jobs",
+      },
+    });
+  }
+
+  for (const registry of jobRegistries) {
+    args.addEdge(
+      exactEdge("depends-on", registry.node.id, jobsPortId, registry.file),
+    );
+    for (const jobId of registeredJobIds(
+      registry.node.id,
+      args.nodes,
+      args.edges,
+    )) {
+      args.addEdge(exactEdge("depends-on", jobId, jobsPortId, registry.file));
+    }
+  }
+
+  const runtimeDirectories = new Set([
+    directoryPath(args.workspace.config.paths.routes),
+    directoryPath(args.workspace.config.paths.server),
+    directoryPath(args.workspace.config.paths.outbox),
+    directoryPath(args.workspace.config.paths.portWiring),
+    "server",
+    "infra",
+  ]);
+  for (const file of args.workspace.files) {
+    if (
+      !isTypeScriptSource(file) ||
+      isTestFile(file) ||
+      ![...runtimeDirectories].some(
+        (directory) =>
+          directory === "." ||
+          file === directory ||
+          file.startsWith(`${directory}/`),
+      )
+    ) {
+      continue;
+    }
+    const sourceFile = await args.workspace.readSourceFile(file);
+    const providerLifecycle = isProviderLifecycleSource(file, sourceFile);
+    const calls: ts.CallExpression[] = [];
+    visitCalls(sourceFile, (call) => {
+      const name = callMemberName(call);
+      if (
+        name === "createOutboxDrainRoute" ||
+        (name === "drainOutbox" && !providerLifecycle)
+      ) {
+        calls.push(call);
+      }
+    });
+    for (const [index, call] of calls.entries()) {
+      const id = `entrypoint:${file}#outbox-drain${index === 0 ? "" : `-${index + 1}`}`;
+      args.addNode({
+        id,
+        kind: "entrypoint",
+        name: `${file} outbox drain`,
+        source: await args.sourceIndex.sourceLocation(file, call),
+        status: "registered",
+        details: { type: "outbox-drain" },
+      });
+
+      const options = call.arguments[0];
+      const registryExpression =
+        options && ts.isObjectLiteralExpression(unwrapExpression(options))
+          ? objectPropertyExpressionAnalysis(
+              unwrapExpression(options) as ts.ObjectLiteralExpression,
+              "registry",
+            ).value
+          : undefined;
+      const reference = registryExpression
+        ? await args.sourceIndex.resolveExpression(file, registryExpression)
+        : undefined;
+      const resolvedRegistry = reference
+        ? outboxRegistries.find(
+            (registry) =>
+              registry.file === reference.file &&
+              registry.node.source.exportName === reference.exportName,
+          )
+        : outboxRegistries.length === 1
+          ? outboxRegistries[0]
+          : undefined;
+      if (resolvedRegistry) {
+        args.addEdge(
+          sourceNodeEdge(
+            "depends-on",
+            id,
+            resolvedRegistry.node.id,
+            file,
+            registryExpression ?? call,
+          ),
+        );
+        if (resolvedRegistry.outbox?.jobs.length) {
+          args.addEdge(
+            sourceNodeEdge("depends-on", id, jobsPortId, file, call),
+          );
+        }
+      } else {
+        args.unresolved.push({
+          code: "outbox_drain_registry_unresolved",
+          message: `Could not resolve the outbox registry used by a drain in ${file}.`,
+          source: await args.sourceIndex.sourceLocation(file, call),
+        });
+      }
+    }
+  }
+}
+
+function isProviderLifecycleSource(
+  file: string,
+  sourceFile: ts.SourceFile,
+): boolean {
+  if (
+    /(^|\/)provider(s)?\.ts$/.test(file) ||
+    /(^|\/)[^/]*provider[^/]*\.ts$/.test(file) ||
+    /(^|\/)providers?\//.test(file)
+  ) {
+    return true;
+  }
+  let providerCall = false;
+  visitCalls(sourceFile, (call) => {
+    if (callMemberName(call) === "createProvider") providerCall = true;
+  });
+  return providerCall;
+}
+
+function registeredJobIds(
+  registryId: string,
+  nodes: Map<string, AppMapNode>,
+  edges: AppMapEdge[],
+): string[] {
+  const visited = new Set<string>([registryId]);
+  let frontier = [registryId];
+  while (frontier.length > 0) {
+    const next: string[] = [];
+    for (const from of frontier) {
+      for (const edge of edges) {
+        if (edge.kind !== "registers" || edge.from !== from) continue;
+        if (visited.has(edge.to)) continue;
+        visited.add(edge.to);
+        next.push(edge.to);
+      }
+    }
+    frontier = next;
+  }
+  return [...visited].filter((id) => nodes.get(id)?.kind === "job").sort();
+}
+
 async function addOpenApiSurface(args: {
   workspace: AnalysisWorkspace;
   inspection: InspectAppResult;
@@ -1298,14 +1520,22 @@ async function addUnresolvedContractDeclarations(args: {
 }): Promise<void> {
   for (const file of appMapContractSourceFiles(args.workspace)) {
     const sourceFile = await args.workspace.readSourceFile(file);
+    const factoryBindings = contractFactoryBindings(sourceFile);
+    const bindingNames = contractBindingNames(sourceFile, factoryBindings);
     for (const { exportName, declaration } of exportedVariableDeclarations(
       sourceFile,
     )) {
       if (args.contractIds.has(symbolKey(file, exportName))) continue;
-      const call = declaration.initializer
-        ? findCall(declaration.initializer, new Set(["defineContract"]))
-        : undefined;
-      if (!call) continue;
+      if (
+        !declaration.initializer ||
+        !isImportedContractDeclaration(
+          declaration.initializer,
+          factoryBindings,
+          bindingNames,
+        )
+      ) {
+        continue;
+      }
 
       args.unresolved.push({
         code: "contract_declaration_unresolved",
@@ -1348,8 +1578,8 @@ async function registryRecord(args: {
 }): Promise<RegistryRecord | undefined> {
   const initializer = args.declaration.initializer;
   if (!initializer) return undefined;
-  const values = registryValues(initializer, args.exportName);
-  if (!values) return undefined;
+  const registry = registryValues(initializer, args.exportName);
+  if (!registry) return undefined;
   const feature = featureForFile(
     args.file,
     directoryPath(args.workspace.config.paths.features),
@@ -1357,7 +1587,8 @@ async function registryRecord(args: {
   return {
     file: args.file,
     declaration: args.declaration,
-    values,
+    values: registry.values,
+    ...(registry.outbox ? { outbox: registry.outbox } : {}),
     node: {
       id: registryId(args.file, args.exportName),
       kind: "registry",
@@ -1369,6 +1600,13 @@ async function registryRecord(args: {
         args.exportName,
       ),
       status: "registered",
+      ...(registry.outbox
+        ? {
+            details: {
+              registryType: "outbox",
+            },
+          }
+        : {}),
     },
   };
 }
@@ -1376,10 +1614,20 @@ async function registryRecord(args: {
 function registryValues(
   initializer: ts.Expression,
   exportName: string,
-): ts.Expression[] | undefined {
+):
+  | {
+      values: ts.Expression[];
+      outbox?: {
+        events: ts.Expression[];
+        jobs: ts.Expression[];
+        eventsIndeterminate: boolean;
+        jobsIndeterminate: boolean;
+      };
+    }
+  | undefined {
   const expression = unwrapExpression(initializer);
   if (ts.isArrayLiteralExpression(expression) && isRegistryName(exportName)) {
-    return arrayExpressions(expression);
+    return { values: arrayExpressions(expression) };
   }
   if (!ts.isCallExpression(expression)) return undefined;
 
@@ -1390,100 +1638,161 @@ function registryValues(
     name === "defineAgentCapabilityRegistry"
   ) {
     const first = expression.arguments[0];
-    return first && ts.isArrayLiteralExpression(unwrapExpression(first))
-      ? arrayExpressions(unwrapExpression(first) as ts.ArrayLiteralExpression)
-      : [];
+    return {
+      values:
+        first && ts.isArrayLiteralExpression(unwrapExpression(first))
+          ? arrayExpressions(
+              unwrapExpression(first) as ts.ArrayLiteralExpression,
+            )
+          : [],
+    };
   }
-  if (
-    name === "defineOutboxRegistry" &&
-    ts.isObjectLiteralExpression(expression.arguments[0])
-  ) {
-    const object = expression.arguments[0];
-    return ["events", "jobs"].flatMap((property) => {
-      const value = propertyAssignment(object, property)?.initializer;
-      return value && ts.isArrayLiteralExpression(unwrapExpression(value))
-        ? arrayExpressions(unwrapExpression(value) as ts.ArrayLiteralExpression)
-        : [];
-    });
+  if (name === "defineOutboxRegistry") {
+    const initializers = localVariableInitializers(expression.getSourceFile());
+    const argument = expression.arguments[0];
+    const object = argument
+      ? resolveRegistryExpression(argument, initializers)
+      : undefined;
+    if (!object || !ts.isObjectLiteralExpression(object)) {
+      return {
+        values: [],
+        outbox: {
+          events: [],
+          jobs: [],
+          eventsIndeterminate: true,
+          jobsIndeterminate: true,
+        },
+      };
+    }
+    const valuesFor = (property: "events" | "jobs") => {
+      const match = objectPropertyExpressionAnalysis(object, property);
+      return {
+        values: match.value
+          ? registryValueExpressions(match.value, initializers)
+          : [],
+        indeterminate: match.indeterminate,
+      };
+    };
+    const events = valuesFor("events");
+    const jobs = valuesFor("jobs");
+    const outbox = {
+      events: events.values,
+      jobs: jobs.values,
+      eventsIndeterminate: events.indeterminate,
+      jobsIndeterminate: jobs.indeterminate,
+    };
+    return { values: [...outbox.events, ...outbox.jobs], outbox };
   }
   if (
     name === "defineUploads" &&
     ts.isObjectLiteralExpression(expression.arguments[0])
   ) {
-    return expression.arguments[0].properties.flatMap((property) =>
-      ts.isPropertyAssignment(property) ? [property.initializer] : [],
-    );
+    return {
+      values: expression.arguments[0].properties.flatMap((property) =>
+        ts.isPropertyAssignment(property) ? [property.initializer] : [],
+      ),
+    };
   }
   return undefined;
 }
 
-function arrayExpressions(array: ts.ArrayLiteralExpression): ts.Expression[] {
-  return array.elements.flatMap((element) => {
-    if (ts.isSpreadElement(element)) return [element.expression];
-    return ts.isExpression(element) ? [element] : [];
-  });
+function objectPropertyExpressionAnalysis(
+  object: ts.ObjectLiteralExpression,
+  name: string,
+): { value?: ts.Expression; indeterminate: boolean } {
+  let value: ts.Expression | undefined;
+  let indeterminate = false;
+  for (const property of object.properties) {
+    if (ts.isSpreadAssignment(property) || !property.name) {
+      value = undefined;
+      indeterminate = true;
+      continue;
+    }
+    const propertyKey = propertyName(property.name);
+    if (!propertyKey) {
+      value = undefined;
+      indeterminate = true;
+      continue;
+    }
+    if (propertyKey !== name) continue;
+    if (ts.isPropertyAssignment(property)) {
+      value = property.initializer;
+      indeterminate = false;
+    } else if (ts.isShorthandPropertyAssignment(property)) {
+      value = property.name;
+      indeterminate = false;
+    } else {
+      value = undefined;
+      indeterminate = true;
+    }
+  }
+  return { ...(value ? { value } : {}), indeterminate };
 }
 
-function collectTypeProperties(
-  type: ts.TypeNode,
-  aliases: Map<string, ts.TypeNode>,
-  visited = new Set<string>(),
-): ts.PropertySignature[] {
-  if (ts.isTypeLiteralNode(type)) {
-    return type.members.filter(ts.isPropertySignature);
+function localVariableInitializers(
+  sourceFile: ts.SourceFile,
+): Map<string, ts.Expression> {
+  const initializers = 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) {
+        initializers.set(declaration.name.text, declaration.initializer);
+      }
+    }
   }
-  if (ts.isIntersectionTypeNode(type)) {
-    return type.types.flatMap((member) =>
-      collectTypeProperties(member, aliases, visited),
+  return initializers;
+}
+
+function resolveRegistryExpression(
+  expression: ts.Expression,
+  initializers: 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 initializer = initializers.get(current.text);
+  if (!initializer) return current;
+  const nextVisited = new Set(visited);
+  nextVisited.add(current.text);
+  return resolveRegistryExpression(initializer, initializers, nextVisited);
+}
+
+function registryValueExpressions(
+  expression: ts.Expression,
+  initializers: Map<string, ts.Expression>,
+  visited = new Set<string>(),
+): ts.Expression[] {
+  const current = unwrapExpression(expression);
+  if (ts.isArrayLiteralExpression(current)) {
+    return current.elements.flatMap((element) =>
+      ts.isSpreadElement(element)
+        ? registryValueExpressions(
+            element.expression,
+            initializers,
+            new Set(visited),
+          )
+        : ts.isExpression(element)
+          ? [element]
+          : [],
     );
   }
-  if (ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName)) {
-    const name = type.typeName.text;
-    if (visited.has(name)) return [];
-    const target = aliases.get(name);
-    if (!target) return [];
-    visited.add(name);
-    return collectTypeProperties(target, aliases, visited);
+  if (ts.isIdentifier(current) && !visited.has(current.text)) {
+    const initializer = initializers.get(current.text);
+    if (initializer) {
+      const nextVisited = new Set(visited);
+      nextVisited.add(current.text);
+      return registryValueExpressions(initializer, initializers, nextVisited);
+    }
   }
-  return [];
+  return [current];
 }
 
-async function readPortBindings(workspace: AnalysisWorkspace): Promise<{
-  bound: Set<string>;
-  deferred: Set<string>;
-}> {
-  const result = { bound: new Set<string>(), deferred: new Set<string>() };
-  const file = workspace.config.paths.portWiring;
-  if (!workspace.fileSet.has(file)) return result;
-  const sourceFile = await workspace.readSourceFile(file);
-
-  visitCalls(sourceFile, (call) => {
-    const object = call.arguments.find(ts.isObjectLiteralExpression);
-    if (
-      !object?.properties.some(
-        (property) =>
-          property.name !== undefined &&
-          propertyName(property.name) === "bound",
-      )
-    ) {
-      return;
-    }
-    const bound = propertyAssignment(object, "bound")?.initializer;
-    if (bound && ts.isObjectLiteralExpression(bound)) {
-      for (const property of bound.properties) {
-        const name = property.name ? propertyName(property.name) : undefined;
-        if (name) result.bound.add(name);
-      }
-    }
-    const deferred = propertyAssignment(object, "deferred")?.initializer;
-    if (deferred && ts.isArrayLiteralExpression(deferred)) {
-      for (const element of deferred.elements) {
-        const name = literalText(element);
-        if (name) result.deferred.add(name);
-      }
-    }
+function arrayExpressions(array: ts.ArrayLiteralExpression): ts.Expression[] {
+  return array.elements.flatMap((element) => {
+    if (ts.isSpreadElement(element)) return [element.expression];
+    return ts.isExpression(element) ? [element] : [];
   });
-  return result;
 }
 
 function discoverFeatureNames(