@intentius/chant 0.68.1 → 0.69.1

package/dist/discovery/import.d.ts

@@ -1,9 +1,23 @@
+/**
+ * Forget every recorded evaluation failure.
+ *
+ * For a harness that deliberately starts a fresh module graph and wants the
+ * failures forgotten with it. Nothing in chant calls this: a real build
+ * imports once, and a second import inside one process is supposed to see what
+ * the first one saw.
+ *
+ * It does not make a module re-evaluate. Node's own registry still holds the
+ * failed record and still re-throws; this only clears chant's memory of it. A
+ * caller wanting genuine re-evaluation needs a fresh process.
+ */
+export declare function resetImportFailures(): void;
 /**
  * Dynamically import a module and return its exports.
  *
  * @param path - The file path to import
  * @returns The module exports
- * @throws {DiscoveryError} with type "import" if the import fails
+ * @throws {DiscoveryError} with type "import" if the import fails, including
+ *   on every later import of a module whose evaluation has already failed
  */
 export declare function importModule(path: string): Promise<Record<string, unknown>>;
 //# sourceMappingURL=import.d.ts.map

package/dist/discovery/import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/discovery/import.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAQlC"}
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/discovery/import.ts"],"names":[],"mappings":"AA4BA;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAalC"}

package/dist/fold/fold.d.ts

@@ -126,9 +126,15 @@ export type FoldedValue = string | number | boolean | null | undefined | FoldedV
  * `undefined` for a value that has an honest string form.
  *
  * These are the shapes `fold()` produces for things the build resolves later:
- * a resource attribute, a lexicon intrinsic in either of its two forms, and a
- * registered authoring helper. None of them can be concatenated into a string
- * here, because what they stand for is not known until the build runs.
+ * a resource attribute, a lexicon intrinsic in either of its two forms, a
+ * registered authoring helper, a nested construction used as a value, and a
+ * composite `.step`. None of them can be concatenated into a string here,
+ * because what they stand for is not known until the build runs.
+ *
+ * Five of the six envelope kinds. `__symbol` is the sixth and is deliberately
+ * absent: it is produced only inside an intrinsic's interior and cannot reach
+ * a plain template span, so a case for it would be unreachable code claiming
+ * to guard something (#2397).
  */
 export declare function symbolicEnvelopeKind(value: unknown): string | undefined;
 export interface AttrRefValue {

package/dist/fold/fold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../src/fold/fold.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../src/fold/fold.ts"],"names":[],"mappings":"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"}

package/dist/lint/rules/evl011-symbolic-in-template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evl011-symbolic-in-template.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/evl011-symbolic-in-template.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAA+B,MAAM,SAAS,CAAC;AAwFrE,eAAO,MAAM,4BAA4B,EAAE,QAU1C,CAAC"}
+{"version":3,"file":"evl011-symbolic-in-template.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/evl011-symbolic-in-template.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAA+B,MAAM,SAAS,CAAC;AA+GrE,eAAO,MAAM,4BAA4B,EAAE,QAU1C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.68.1",
+  "version": "0.69.1",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/discovery/import.test.ts

@@ -1,9 +1,10 @@
 import { describe, test, expect } from "vitest";
-import { importModule } from "./import";
+import { importModule, resetImportFailures } from "./import";
+import { discover } from "./index";
 import { DiscoveryError } from "../errors";
 import { withTestDir, expectToThrow } from "@intentius/chant-test-utils";
 import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 
 describe("importModule", () => {
 
@@ -198,3 +199,110 @@ describe("importModule", () => {
     });
   });
 });
+
+describe("a module whose evaluation threw stays thrown (#2368)", () => {
+  /**
+   * The spec records an evaluation failure on the module record and re-throws
+   * it on every later import, forever. Node does that; vitest's module runner
+   * does not, and hands the second importer a namespace holding whatever was
+   * initialized before the throw.
+   *
+   * These assert the contract directly. They do not reproduce the runner bug —
+   * a module written to a temp directory is outside vitest's transform root and
+   * is imported by Node, which already records the failure. The reproduction is
+   * the corpus-backed test at the bottom of this file, which is the one that
+   * fails without the failure map.
+   */
+  test("a second import throws the same error, not a half-initialized namespace", async () => {
+    await withTestDir(async (testDir) => {
+      const filePath = join(testDir, "throws.ts");
+      await writeFile(filePath, `const o = undefined as unknown as { k: string };\nexport const value = o.k;\n`);
+
+      const first = await expectToThrow(() => importModule(filePath), DiscoveryError);
+      const second = await expectToThrow(() => importModule(filePath), DiscoveryError);
+
+      expect(second.message).toBe(first.message);
+      expect(second.file).toBe(filePath);
+      // The same error object, because it is the recorded one being replayed
+      // rather than a second failure that happened to look alike.
+      expect(second).toBe(first);
+    });
+  });
+
+  test("a third and fourth import keep throwing", async () => {
+    await withTestDir(async (testDir) => {
+      const filePath = join(testDir, "throws-again.ts");
+      await writeFile(filePath, `const o = undefined as unknown as { k: string };\nexport const value = o.k;\n`);
+
+      await expectToThrow(() => importModule(filePath), DiscoveryError);
+      await expectToThrow(() => importModule(filePath), DiscoveryError);
+      await expectToThrow(() => importModule(filePath), DiscoveryError);
+      await expectToThrow(() => importModule(filePath), DiscoveryError);
+    });
+  });
+
+  test("a module that imports cleanly is unaffected and is not cached as failed", async () => {
+    await withTestDir(async (testDir) => {
+      const filePath = join(testDir, "fine.ts");
+      await writeFile(filePath, `export const value = "ok";\n`);
+
+      const a = await importModule(filePath);
+      const b = await importModule(filePath);
+      expect(a.value).toBe("ok");
+      expect(b.value).toBe("ok");
+    });
+  });
+
+  test("resetImportFailures forgets the record, and does not make the module re-evaluate", async () => {
+    await withTestDir(async (testDir) => {
+      const filePath = join(testDir, "throws-reset.ts");
+      await writeFile(filePath, `const o = undefined as unknown as { k: string };\nexport const value = o.k;\n`);
+
+      const first = await expectToThrow(() => importModule(filePath), DiscoveryError);
+      resetImportFailures();
+
+      // Under Node the registry still holds the failed record and throws
+      // again; under vitest the module is served from its cache. Either way
+      // the escape hatch only clears chant's memory, which is what its doc
+      // says — so this asserts the clearing, not a re-evaluation.
+      let replayedSameObject = false;
+      try {
+        await importModule(filePath);
+      } catch (err) {
+        replayedSameObject = err === first;
+      }
+      expect(replayedSameObject).toBe(false);
+    });
+  });
+});
+
+describe("discover() reports the same errors on a second pass (#2368)", () => {
+  /**
+   * The reproduction from the issue, over the corpus entry that exposed it.
+   *
+   * It has to be a file inside the project: vitest transforms and caches those,
+   * and it is that cache which forgets an evaluation failure. A module written
+   * to a temp directory outside the runner's root is imported by Node natively
+   * and already behaves correctly, so a fixture built with `withTestDir` would
+   * pass with or without the fix and prove nothing.
+   *
+   * `examples/fold-adversarial/src/nullish-property-read.ts` folds to a refusal
+   * and then throws a TypeError when the run path imports it (#2328). Before
+   * the failure map: `discover #1 errors=1`, `discover #2 errors=0`.
+   */
+  const ADVERSARIAL = resolve(import.meta.dirname, "../../../../examples/fold-adversarial/src");
+
+  test("the corpus entry with a throwing file reports it on every pass", async () => {
+    const first = await discover(ADVERSARIAL);
+    const second = await discover(ADVERSARIAL);
+    const third = await discover(ADVERSARIAL);
+
+    expect(first.errors.length).toBeGreaterThan(0);
+    expect(second.errors.length).toBe(first.errors.length);
+    expect(third.errors.length).toBe(first.errors.length);
+
+    const named = (r: { errors: unknown[] }): boolean =>
+      (r.errors[0] as { file?: string }).file?.endsWith("nullish-property-read.ts") === true;
+    expect(named(first) && named(second) && named(third)).toBe(true);
+  });
+});

package/src/discovery/import.ts

@@ -1,20 +1,68 @@
 import { DiscoveryError } from "../errors";
 
+/**
+ * Modules whose evaluation threw, and the error each threw with (#2368).
+ *
+ * The ES module spec says an evaluation failure is recorded on the module
+ * record and re-thrown on every later import of the same specifier, forever,
+ * in that realm. Node implements it — including after the file is edited, so a
+ * module that threw keeps throwing until the process restarts.
+ *
+ * Vitest's module runner does not. It caches the module as *evaluated* and
+ * hands later importers a namespace carrying whichever bindings were
+ * initialized before the throw, so the second import resolves with
+ * half-initialized exports and no error at all.
+ *
+ * That divergence is invisible to `chant build`, which imports a directory
+ * once per process, and highly visible to anything that builds the same
+ * directory twice and compares: whichever build ran first carried the error
+ * and every build after it reported none, so error parity came out of the
+ * ordering rather than out of the tool.
+ *
+ * This map is what makes the answer the same either way. Under Node it never
+ * fires — `import()` throws again before the lookup matters — so it costs
+ * nothing and changes nothing there. Under a runner that forgets, it supplies
+ * the memory the spec requires.
+ */
+const evaluationFailures = new Map<string, DiscoveryError>();
+
+/**
+ * Forget every recorded evaluation failure.
+ *
+ * For a harness that deliberately starts a fresh module graph and wants the
+ * failures forgotten with it. Nothing in chant calls this: a real build
+ * imports once, and a second import inside one process is supposed to see what
+ * the first one saw.
+ *
+ * It does not make a module re-evaluate. Node's own registry still holds the
+ * failed record and still re-throws; this only clears chant's memory of it. A
+ * caller wanting genuine re-evaluation needs a fresh process.
+ */
+export function resetImportFailures(): void {
+  evaluationFailures.clear();
+}
+
 /**
  * Dynamically import a module and return its exports.
  *
  * @param path - The file path to import
  * @returns The module exports
- * @throws {DiscoveryError} with type "import" if the import fails
+ * @throws {DiscoveryError} with type "import" if the import fails, including
+ *   on every later import of a module whose evaluation has already failed
  */
 export async function importModule(
   path: string
 ): Promise<Record<string, unknown>> {
+  const failed = evaluationFailures.get(path);
+  if (failed) throw failed;
+
   try {
     return await import(path);
   } catch (error) {
     const message =
       error instanceof Error ? error.message : "Unknown import error";
-    throw new DiscoveryError(path, message, "import");
+    const discoveryError = new DiscoveryError(path, message, "import");
+    evaluationFailures.set(path, discoveryError);
+    throw discoveryError;
   }
 }

package/src/fold/fold.test.ts

@@ -100,6 +100,29 @@ describe("fold — a symbolic value in a plain template (#2349)", () => {
     expect(() => "prefix" + (bucket.arn as unknown as string)).toThrow(/no string form/);
   });
 
+
+  test("a nested construction used as a value is refused too (#2397)", () => {
+    const src = `
+      const x = \`\${new S3Bucket({ BucketName: "b" })}-tag\`;
+    `;
+    expect(() => foldConst(src, "x")).toThrow(FoldError);
+    try {
+      foldConst(src, "x");
+    } catch (e) {
+      expect((e as FoldError).message).toContain("new S3Bucket");
+      expect((e as FoldError).message).toContain("[object Object]");
+    }
+  });
+
+  test("a composite `.step` is refused too (#2397)", () => {
+    // The run path builds a real instance whose default toString is the same
+    // "[object Object]", so this agreed across paths exactly as #2349 did.
+    const src = `
+      const x = \`\${Checkout({}).step}\`;
+    `;
+    expect(() => foldConst(src, "x")).toThrow(FoldError);
+  });
+
   test("an ordinary value in a template still interpolates", () => {
     const src = `
       const region = "us-east-1";

package/src/fold/fold.ts

@@ -156,9 +156,15 @@ export type FoldedValue =
  * `undefined` for a value that has an honest string form.
  *
  * These are the shapes `fold()` produces for things the build resolves later:
- * a resource attribute, a lexicon intrinsic in either of its two forms, and a
- * registered authoring helper. None of them can be concatenated into a string
- * here, because what they stand for is not known until the build runs.
+ * a resource attribute, a lexicon intrinsic in either of its two forms, a
+ * registered authoring helper, a nested construction used as a value, and a
+ * composite `.step`. None of them can be concatenated into a string here,
+ * because what they stand for is not known until the build runs.
+ *
+ * Five of the six envelope kinds. `__symbol` is the sixth and is deliberately
+ * absent: it is produced only inside an intrinsic's interior and cannot reach
+ * a plain template span, so a case for it would be unreachable code claiming
+ * to guard something (#2397).
  */
 export function symbolicEnvelopeKind(value: unknown): string | undefined {
   if (typeof value !== "object" || value === null) return undefined;
@@ -173,6 +179,15 @@ export function symbolicEnvelopeKind(value: unknown): string | undefined {
   }
   if ("__intrinsic" in v && typeof v.__intrinsic === "string") return `the intrinsic \`${v.__intrinsic}\``;
   if ("__helper" in v && typeof v.__helper === "string") return `the helper \`${v.__helper}\``;
+  // A nested construction used as a value (#1169). The run path builds a real
+  // instance here, whose default `toString` is `"[object Object]"` too, so
+  // fold and run agreed and the differential stayed silent — the same shape
+  // as #2349 itself (#2397).
+  if ("__resource" in v && typeof v.__resource === "string") return `a nested \`new ${v.__resource}\``;
+  // The `.step` idiom (#1174).
+  if ("__compositeStep" in v && typeof v.__compositeStep === "string") {
+    return `the composite step \`${v.__compositeStep}(…).step\``;
+  }
   return undefined;
 }
 

package/src/lint/rules/evl011-symbolic-in-template.test.ts

@@ -65,6 +65,34 @@ describe("EVL011: a symbolic reference in a plain template", () => {
     expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(0);
   });
 
+
+  test("flags a nested construction used as a value (#2397)", () => {
+    const ctx = createContext(`
+      const x = \`\${new Image({ name: "n" })}-tag\`;
+    `);
+    const found = evl011SymbolicInTemplateRule.check(ctx);
+    expect(found).toHaveLength(1);
+    expect(found[0].message).toContain("new Image");
+  });
+
+  test("flags a composite `.step` (#2397)", () => {
+    const ctx = createContext(`
+      const x = \`\${Checkout({}).step}\`;
+    `);
+    const found = evl011SymbolicInTemplateRule.check(ctx);
+    expect(found).toHaveLength(1);
+    expect(found[0].message).toContain("Checkout(…).step");
+  });
+
+  test("an ordinary `.step`-less property on a call is not flagged", () => {
+    // The false positive worth avoiding: `.step` is the idiom, and a rule
+    // cannot know which callees are composites, so only that name qualifies.
+    const ctx = createContext(`
+      const x = \`\${getConfig().region}\`;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(0);
+  });
+
   test("says nothing about a reference outside a template", () => {
     const ctx = createContext(`
       const bucket = new S3Bucket({ name: "b" });

package/src/lint/rules/evl011-symbolic-in-template.ts

@@ -49,6 +49,33 @@ function resourceBindings(sourceFile: ts.SourceFile): Set<string> {
   return names;
 }
 
+/**
+ * What this span is, if it is one of the shapes that has no string form — or
+ * `undefined` for an ordinary expression.
+ *
+ * The three kinds a syntactic rule can see, matching what `fold()` refuses
+ * (#2397): a resource attribute on an identifier bound by `new` in this file,
+ * a nested construction used as a value, and a composite `.step`.
+ */
+function symbolicSpan(expr: ts.Expression, bound: Set<string>): string | undefined {
+  if (ts.isNewExpression(expr)) {
+    const name = ts.isIdentifier(expr.expression) ? expr.expression.text : "…";
+    return `a nested \`new ${name}\``;
+  }
+  if (ts.isPropertyAccessExpression(expr)) {
+    // `Checkout({}).step` — a call's `.step`, whatever the callee is: the
+    // idiom is the shape, and a rule cannot know which callees are composites.
+    if (expr.name.text === "step" && ts.isCallExpression(expr.expression)) {
+      const callee = ts.isIdentifier(expr.expression.expression) ? expr.expression.expression.text : "…";
+      return `the composite step \`${callee}(…).step\``;
+    }
+    if (ts.isIdentifier(expr.expression) && bound.has(expr.expression.text)) {
+      return `\`${expr.expression.text}.${expr.name.text}\` is a resource attribute and`;
+    }
+  }
+  return undefined;
+}
+
 function checkNode(
   node: ts.Node,
   context: LintContext,
@@ -60,11 +87,8 @@ function checkNode(
   if (ts.isTemplateExpression(node) && !ts.isTaggedTemplateExpression(node.parent)) {
     for (const span of node.templateSpans) {
       const expr = span.expression;
-      if (
-        ts.isPropertyAccessExpression(expr) &&
-        ts.isIdentifier(expr.expression) &&
-        bound.has(expr.expression.text)
-      ) {
+      const what = symbolicSpan(expr, bound);
+      if (what) {
         const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
           expr.getStart(context.sourceFile),
         );
@@ -75,10 +99,9 @@ function checkNode(
           ruleId: "EVL011",
           severity: "error",
           message:
-            `\`${expr.expression.text}.${expr.name.text}\` is a resource attribute and has no string ` +
-            "form until the build resolves it — a plain template would stringify it as " +
-            "\"[object Object]\". Use the lexicon's own intrinsic, whose interior handles references " +
-            "(`Sub`${…}`` for CloudFormation), or move the reference out of the template.",
+            `${what} has no string form until the build resolves it — a plain template would ` +
+            "stringify it as \"[object Object]\". Use the lexicon's own intrinsic, whose interior " +
+            "handles these (`Sub`${…}`` for CloudFormation), or move it out of the template.",
         });
       }
     }