@intentius/chant 0.32.0 → 0.33.0

package/src/lifecycle/observe.test.ts

@@ -1,9 +1,25 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi } from "vitest";
 import { observeResources } from "./observe";
 import { observation } from "../observation";
 import type { ObservationLexicon, ResourceMetadata } from "../lexicon";
 import type { BuildResult } from "../build";
 
+// The per-stack scoped build (#1162) resolves each stack's `src` through the
+// real `build`. Mock it so the test controls what each src yields — a stack
+// whose src is scoped reports BARE entity names, matching the deployed
+// LogicalResourceIds, not the whole-project build's disambiguated names.
+const scopedBuilds: Record<string, string[]> = {};
+vi.mock("../build", () => ({
+  build: async (src: string): Promise<BuildResult> => {
+    const names = scopedBuilds[src] ?? [];
+    return {
+      outputs: new Map<string, string>([["aws", "{}"]]),
+      entities: new Map(names.map((n) => [n, { lexicon: "aws", entityType: "AWS::EC2::Instance", props: {} }])),
+      errors: [],
+    } as unknown as BuildResult;
+  },
+}));
+
 function mockBuild(): BuildResult {
   return {
     outputs: new Map<string, string>([["aws", "{}"]]),
@@ -154,7 +170,11 @@ describe("observeResources", () => {
       awsPlugin((opts) => {
         const stack = (opts as { stack?: string }).stack;
         calls.push(stack);
-        // Different resources per stack — the multi-stack, per-component case.
+        // Different resources per stack — the multi-stack, per-component case
+        // (#57 loomster). Bare-string stacks keep BARE ids (no `src` scope), so
+        // the union is `db-a`+`db-b`, not stack-qualified: per-component ids are
+        // already unique and behold reads them bare. Qualification is a scoped
+        // (`src`) feature — see the per-stack src test below.
         const resources: Record<string, ResourceMetadata> =
           stack === "s1"
             ? { "db-a": { type: "AWS::RDS::DBInstance", status: "AVAILABLE" } }
@@ -169,6 +189,50 @@ describe("observeResources", () => {
     expect(Object.keys(observations[0].resources).sort()).toEqual(["db-a", "db-b"]);
   });
 
+  it("with per-stack src (#1162): describeResources gets each stack's SCOPED bare names, not the whole-project build's names", async () => {
+    const { resolve } = await import("node:path");
+    // The whole-project build disambiguates colliding names by module path;
+    // each stack's scoped src reports the bare names it actually deploys.
+    scopedBuilds[resolve("east/src")] = ["server", "vpc"];
+    scopedBuilds[resolve("west/src")] = ["server", "vpc"];
+
+    const seen: Record<string, string[]> = {};
+    const plugins = [
+      awsPlugin((opts) => {
+        const o = opts as { stack?: string; entityNames: string[] };
+        seen[o.stack ?? "?"] = o.entityNames;
+        // Echo one resource keyed by a bare name the deployed stack owns.
+        return { server: { type: "AWS::EC2::Instance", status: "AVAILABLE", physicalId: `i-${o.stack}` } };
+      }),
+    ];
+    // The whole-project buildResult carries DISAMBIGUATED names — proving the
+    // scoped path overrides them rather than falling through to these.
+    const wholeProject = {
+      outputs: new Map<string, string>([["aws", "{}"]]),
+      entities: new Map([
+        ["EastServer", { lexicon: "aws", entityType: "AWS::EC2::Instance", props: {} }],
+        ["WestServer", { lexicon: "aws", entityType: "AWS::EC2::Instance", props: {} }],
+      ]),
+      errors: [],
+    } as unknown as BuildResult;
+
+    const { observations } = await observeResources("floci", plugins, wholeProject, {
+      stacks: [
+        { name: "east", src: "east/src" },
+        { name: "west", src: "west/src" },
+      ],
+    });
+
+    // Each stack saw its own scoped bare names (matching deployed ids).
+    expect(seen["east"]).toEqual(["server", "vpc"]);
+    expect(seen["west"]).toEqual(["server", "vpc"]);
+    // Observed nodes are stack-qualified, so the colliding `server` id is
+    // distinct per stack and each carries its own physical id.
+    expect(Object.keys(observations[0].resources).sort()).toEqual(["east::server", "west::server"]);
+    expect(observations[0].resources["east::server"].physicalId).toBe("i-east");
+    expect(observations[0].resources["west::server"].physicalId).toBe("i-west");
+  });
+
   it("with an empty stacks array — falls back to the single unstacked call", async () => {
     const calls: Array<{ stack?: string }> = [];
     const plugins = [

package/src/lifecycle/observe.ts

@@ -11,6 +11,8 @@
  */
 import type { ObservationLexicon } from "../lexicon";
 import type { BuildResult } from "../build";
+import { build as buildProject } from "../build";
+import { resolve as resolvePath } from "node:path";
 import type { SerializerResult } from "../serializer";
 import type { LiveObservation } from "../graph-ir";
 import {
@@ -28,6 +30,19 @@ export interface ObserveResult {
   errors: string[];
 }
 
+/**
+ * Re-key a normalized observation's entities by `${stack}::${id}` (#1162) so a
+ * bare LogicalResourceId shared across stacks (e.g. `vpc`) stays unambiguous
+ * once the per-stack results are merged. The declared canvas qualifies the same
+ * way (`buildDeclaredPerStack`), so the overlay join lines up. Applies to both
+ * the OBSERVED-PRESENT and NOT-OBSERVED maps of the tri-state (#1089).
+ */
+function qualifyObservation(obs: NormalizedObservation, stackName: string): NormalizedObservation {
+  const q = <T>(m: Record<string, T>): Record<string, T> =>
+    Object.fromEntries(Object.entries(m).map(([k, v]) => [`${stackName}::${k}`, v]));
+  return { resources: q(obs.resources), unobserved: q(obs.unobserved) };
+}
+
 /**
  * Query every plugin that implements `describeResources` for its resources in
  * `environment`. `owned` (default true for the managed-only diagram, epic #776)
@@ -44,20 +59,39 @@ export interface ObserveResult {
  * absent an explicit `stack`) queries a stack that simply doesn't exist there,
  * so the single-call path always observes zero nodes. When `stacks` is
  * present and non-empty, each observing plugin's `describeResources` is
- * called once per stack (same `environment`/`entities`/`entityNames`, only
- * `stack` varies) and the returned resource maps are unioned — a resource
- * appears under whichever stack contains its logical id. When `stacks` is
- * absent or empty, behavior is exactly the single call of before (no `stack`
- * key at all), so a single-stack project is unaffected.
+ * called once per stack and the returned observations are merged. A stack entry
+ * may be a bare name or `{ name, region?, src? }` (#1162): `src` is built
+ * SCOPED so the deployed BARE LogicalResourceIds match (the whole-project build
+ * disambiguates colliding names to `UsWest1Src…`, which the live ids never
+ * carry), and a scoped stack's observed ids are qualified `${stack}::${id}` so
+ * the same bare id in two stacks stays distinct. A bare-string stack keeps its
+ * bare ids and the tri-state merge (#57). When `stacks` is absent or empty, behavior is
+ * exactly the single call of before (no `stack` key at all), so a single-stack
+ * project is unaffected.
  */
 export async function observeResources(
   environment: string,
   plugins: ObservationLexicon[],
   buildResult: BuildResult,
-  opts?: { owned?: boolean; stacks?: string[] },
+  opts?: { owned?: boolean; stacks?: Array<string | { name: string; region?: string; src?: string }> },
 ): Promise<ObserveResult> {
   const owned = opts?.owned ?? true;
-  const stacks = opts?.stacks ?? [];
+  const stacks = (opts?.stacks ?? []).map((st) => (typeof st === "string" ? { name: st } : st));
+  // A stack's `src` (multi-stack, #1162) is built SCOPED to recover that stack's
+  // BARE entity names — the names it actually deploys. Matching deployed bare
+  // LogicalResourceIds against the whole-project build's DISAMBIGUATED names
+  // (UsWest1Src…) misses every colliding resource. Cached per src.
+  const serializers = plugins.map((p) => p.serializer);
+  const scopedBuildCache = new Map<string, BuildResult>();
+  const scopedBuild = async (src: string): Promise<BuildResult> => {
+    const key = resolvePath(src);
+    let r = scopedBuildCache.get(key);
+    if (!r) {
+      r = await buildProject(key, serializers);
+      scopedBuildCache.set(key, r);
+    }
+    return r;
+  };
   const observations: LiveObservation[] = [];
   const warnings: string[] = [];
   const errors: string[] = [];
@@ -91,18 +125,45 @@ export async function observeResources(
       if (stacks.length > 0) {
         const parts: NormalizedObservation[] = [];
         for (const stack of stacks) {
-          parts.push(
-            normalizeObservation(
-              await plugin.describeResources({
-                environment,
-                buildOutput,
-                entityNames,
-                entities,
-                owned,
-                stack,
-              }),
-            ),
+          // Use this stack's scoped build (bare entity names) when it has a src,
+          // so describeResources matches the deployed bare LogicalResourceIds.
+          let stackEntityNames = entityNames;
+          let stackBuildOutput = buildOutput;
+          let stackEntities = entities;
+          if (stack.src) {
+            const sb = await scopedBuild(stack.src);
+            stackEntityNames = [];
+            stackEntities = new Map();
+            for (const [name, entity] of sb.entities) {
+              if (entity.lexicon !== plugin.name) continue;
+              stackEntityNames.push(name);
+              stackEntities.set(name, {
+                entityType: entity.entityType,
+                props: ("props" in entity && entity.props != null ? entity.props : {}) as Record<string, unknown>,
+              });
+            }
+            const raw = sb.outputs.get(plugin.name);
+            stackBuildOutput = raw === undefined ? "" : typeof raw === "string" ? raw : (raw as SerializerResult).primary;
+          }
+          const norm = normalizeObservation(
+            await plugin.describeResources({
+              environment,
+              buildOutput: stackBuildOutput,
+              entityNames: stackEntityNames,
+              entities: stackEntities,
+              owned,
+              stack: stack.name,
+              region: stack.region,
+            }),
           );
+          // Qualify ids by stack ONLY for a scoped (`src`) stack (#1162): that
+          // is the multi-region case where the SAME bare LogicalResourceId
+          // (e.g. `vpc`) exists in every stack, so a bare union would collide.
+          // A bare-string stack (#57 loomster) has unique per-component ids and
+          // is asked the whole-project entity set, so it keeps the bare-id
+          // tri-state merge (present > not-observed > absent) that behold and
+          // other consumers read.
+          parts.push(stack.src ? qualifyObservation(norm, stack.name) : norm);
         }
         observed = mergeObservations(parts);
       } else {