@beignet/cli 0.0.48 → 0.0.49

package/dist/app-map.js

@@ -1,5 +1,7 @@
 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, literalText, localImportReferences, propertyAssignment, propertyName, visitCalls, } from "./analysis/source-index.js";
 import { createAnalysisWorkspace, } from "./analysis/workspace.js";
 import { directoryPath } from "./config.js";
@@ -287,6 +289,20 @@ export async function mapApp(options = {}) {
             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,
+                    });
+                }
             }
         }
     }
@@ -402,6 +418,17 @@ export async function mapApp(options = {}) {
         sourceIndex,
         addNode,
         addEdge,
+        unresolved,
+    });
+    await addOutboxDeliveryGraph({
+        workspace,
+        sourceIndex,
+        registries,
+        nodes,
+        edges,
+        addNode,
+        addEdge,
+        unresolved,
     });
     await addTables({ workspace, sourceIndex, addNode });
     await addUnresolvedLocalImports({ workspace, unresolved });
@@ -657,45 +684,51 @@ async function addPorts(args) {
     if (!args.workspace.fileSet.has(portsFile))
         return;
     const sourceFile = await args.workspace.readSourceFile(portsFile);
-    const aliases = new Map();
-    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),
-            status: bindings.bound.has(name) || bindings.deferred.has(name)
+            source: property
+                ? await args.sourceIndex.sourceLocation(portsFile, property)
+                : { file: args.workspace.config.paths.portWiring },
+            status: 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,
@@ -709,6 +742,128 @@ async function addPorts(args) {
         }
     }
 }
+async function addOutboxDeliveryGraph(args) {
+    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 = [];
+        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), "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, sourceFile) {
+    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, nodes, edges) {
+    const visited = new Set([registryId]);
+    let frontier = [registryId];
+    while (frontier.length > 0) {
+        const next = [];
+        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) {
     const file = args.workspace.config.paths.openapiRoute;
     if (!args.workspace.fileSet.has(file))
@@ -847,14 +1002,15 @@ async function addUnresolvedLocalImports(args) {
 async function addUnresolvedContractDeclarations(args) {
     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)
+            if (!declaration.initializer ||
+                !isImportedContractDeclaration(declaration.initializer, factoryBindings, bindingNames)) {
                 continue;
+            }
             args.unresolved.push({
                 code: "contract_declaration_unresolved",
                 message: `Could not resolve the HTTP method and path for contract ${exportName}.`,
@@ -883,14 +1039,15 @@ async function registryRecord(args) {
     const initializer = args.declaration.initializer;
     if (!initializer)
         return undefined;
-    const values = registryValues(initializer, args.exportName);
-    if (!values)
+    const registry = registryValues(initializer, args.exportName);
+    if (!registry)
         return undefined;
     const feature = featureForFile(args.file, directoryPath(args.workspace.config.paths.features));
     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",
@@ -898,13 +1055,20 @@ async function registryRecord(args) {
             ...(feature ? { feature } : {}),
             source: await args.sourceIndex.sourceLocation(args.file, args.declaration, args.exportName),
             status: "registered",
+            ...(registry.outbox
+                ? {
+                    details: {
+                        registryType: "outbox",
+                    },
+                }
+                : {}),
         },
     };
 }
 function registryValues(initializer, exportName) {
     const expression = unwrapExpression(initializer);
     if (ts.isArrayLiteralExpression(expression) && isRegistryName(exportName)) {
-        return arrayExpressions(expression);
+        return { values: arrayExpressions(expression) };
     }
     if (!ts.isCallExpression(expression))
         return undefined;
@@ -913,82 +1077,137 @@ function registryValues(initializer, exportName) {
         name === "defineNotificationRegistry" ||
         name === "defineAgentCapabilityRegistry") {
         const first = expression.arguments[0];
-        return first && ts.isArrayLiteralExpression(unwrapExpression(first))
-            ? arrayExpressions(unwrapExpression(first))
-            : [];
+        return {
+            values: first && ts.isArrayLiteralExpression(unwrapExpression(first))
+                ? arrayExpressions(unwrapExpression(first))
+                : [],
+        };
     }
-    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))
-                : [];
-        });
+    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) => {
+            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) {
-    return array.elements.flatMap((element) => {
-        if (ts.isSpreadElement(element))
-            return [element.expression];
-        return ts.isExpression(element) ? [element] : [];
-    });
-}
-function collectTypeProperties(type, aliases, visited = new Set()) {
-    if (ts.isTypeLiteralNode(type)) {
-        return type.members.filter(ts.isPropertySignature);
-    }
-    if (ts.isIntersectionTypeNode(type)) {
-        return type.types.flatMap((member) => collectTypeProperties(member, aliases, visited));
-    }
-    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);
+function objectPropertyExpressionAnalysis(object, name) {
+    let value;
+    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 [];
+    return { ...(value ? { value } : {}), indeterminate };
 }
-async function readPortBindings(workspace) {
-    const result = { bound: new Set(), deferred: new Set() };
-    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);
+function localVariableInitializers(sourceFile) {
+    const initializers = new Map();
+    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);
             }
         }
-        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);
-            }
+    }
+    return initializers;
+}
+function resolveRegistryExpression(expression, initializers, visited = new Set()) {
+    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, initializers, visited = new Set()) {
+    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.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 [current];
+}
+function arrayExpressions(array) {
+    return array.elements.flatMap((element) => {
+        if (ts.isSpreadElement(element))
+            return [element.expression];
+        return ts.isExpression(element) ? [element] : [];
     });
-    return result;
 }
 function discoverFeatureNames(workspace, featuresPath) {
     const names = new Set();