@intentius/chant-lexicon-aws 0.55.0 → 0.57.0

package/src/generated/index.ts

@@ -10765,5 +10765,5 @@ export const ZonalShiftConfig = createProperty("AWS::EKS::Cluster.ZonalShiftConf
 export const ZookeeperAccess = createProperty("AWS::MSK::Cluster.ZookeeperAccess", "aws");
 
 // Re-exports for convenience
-export { Sub, Ref, GetAtt, If, Join, Select, Split, Base64 } from "../intrinsics";
+export { Sub, Ref, GetAtt, If, Join, Select, Split, Base64, Equals, Not } from "../intrinsics";
 export { AWS, StackName, Region, AccountId, StackId, URLSuffix, NoValue, NotificationARNs } from "../pseudo";

package/src/import/generator.ts

@@ -1,6 +1,6 @@
 import { loadLexiconRegistry } from "@intentius/chant/codegen/registry";
 import { createRequire } from "module";
-import type { TemplateIR, ResourceIR, ParameterIR } from "@intentius/chant/import/parser";
+import type { TemplateIR, ResourceIR, ParameterIR, ConditionIR, OutputIR } from "@intentius/chant/import/parser";
 const require = createRequire(import.meta.url);
 import type { TypeScriptGenerator, GeneratedFile } from "@intentius/chant/import/generator";
 import { topoSort } from "@intentius/chant/codegen/topo-sort";
@@ -51,12 +51,33 @@ export class CFGenerator implements TypeScriptGenerator {
       lines.push("");
     }
 
+    // Generate conditions in dependency order ({ Condition: ... } references
+    // point at earlier declarations) — #2069
+    const conditions = ir.conditions ?? [];
+    const sortedConditions = this.sortConditions(conditions);
+    for (const condition of sortedConditions) {
+      lines.push(this.generateCondition(condition, ir, importedSymbols));
+    }
+
+    if (conditions.length > 0) {
+      lines.push("");
+    }
+
     // Generate resources in dependency order
     const sortedResources = this.sortByDependencies(ir.resources);
     for (const resource of sortedResources) {
       lines.push(this.generateResource(resource, ir, importedSymbols));
     }
 
+    // Generate outputs (#2069)
+    const outputs = ir.outputs ?? [];
+    if (outputs.length > 0) {
+      lines.push("");
+      for (const output of outputs) {
+        lines.push(this.generateOutput(output, ir, importedSymbols));
+      }
+    }
+
     return [
       {
         path: "main.ts",
@@ -71,10 +92,14 @@ export class CFGenerator implements TypeScriptGenerator {
   private collectImportedSymbols(ir: TemplateIR): Set<string> {
     const symbols = new Set<string>();
     if (ir.parameters.length > 0) symbols.add("Parameter");
-    const intrinsics = ["Sub", "Ref", "If", "Join", "Select", "Split", "Base64", "GetAZs", "GetAtt"] as const;
+    if ((ir.conditions ?? []).length > 0) symbols.add("Condition");
+    if ((ir.outputs ?? []).length > 0) symbols.add("stackOutput");
+    const intrinsics = ["Sub", "Ref", "If", "Join", "Select", "Split", "Base64", "GetAZs", "GetAtt", "Equals", "And", "Or", "Not"] as const;
     for (const name of intrinsics) {
       if (irUsesIntrinsic(ir, name)) symbols.add(name);
     }
+    // Outputs whose value is a Ref envelope render as Ref(<var>) (#2069)
+    if ((ir.outputs ?? []).some((o) => hasIntrinsicInValue(o.value, "Ref"))) symbols.add("Ref");
     if (this.needsAWSPseudo(ir)) symbols.add("AWS");
     for (const resource of ir.resources) {
       const parsed = this.parseResourceType(resource.type);
@@ -94,54 +119,14 @@ export class CFGenerator implements TypeScriptGenerator {
    * Generate import statements
    */
   private generateImports(ir: TemplateIR): string {
-    const imports: Set<string> = new Set();
-    const serviceImports: Map<string, Set<string>> = new Map();
-
-    // Collect what we need to import
-    const needsParameter = ir.parameters.length > 0;
-    if (needsParameter) {
-      imports.add("Parameter");
-    }
-
-    // Check for intrinsics
-    const intrinsics = ["Sub", "Ref", "If", "Join", "Select", "Split", "Base64", "GetAZs", "GetAtt"] as const;
-    for (const name of intrinsics) {
-      if (irUsesIntrinsic(ir, name)) imports.add(name);
-    }
-
-    // Check for AWS pseudo-parameters
-    if (this.needsAWSPseudo(ir)) {
-      imports.add("AWS");
-    }
-
-    // Collect service imports (skip unknown resource types)
-    for (const resource of ir.resources) {
-      const parsed = this.parseResourceType(resource.type);
-      if (!parsed) continue;
-      const { service, resourceClass } = parsed;
-      if (!serviceImports.has(service)) {
-        serviceImports.set(service, new Set());
-      }
-      serviceImports.get(service)!.add(resourceClass);
-    }
-
-    // Build import lines
-    const importLines: string[] = [];
-
-    // Merge service resource imports into the core imports set
-    for (const [_service, resources] of serviceImports) {
-      for (const r of resources) {
-        imports.add(r);
-      }
+    // Everything comes from the flat @intentius/chant-lexicon-aws package,
+    // and the needed symbol set is exactly what collectImportedSymbols
+    // computes for variable-name conflict detection.
+    const allImports = [...this.collectImportedSymbols(ir)];
+    if (allImports.length === 0) {
+      return "";
     }
-
-    // All imports come from the flat @intentius/chant-lexicon-aws package
-    const allImports = [...imports];
-    if (allImports.length > 0) {
-      importLines.push(`import { ${allImports.join(", ")} } from "@intentius/chant-lexicon-aws";`);
-    }
-
-    return importLines.join("\n");
+    return `import { ${allImports.join(", ")} } from "@intentius/chant-lexicon-aws";`;
   }
 
   /**
@@ -237,6 +222,76 @@ export class CFGenerator implements TypeScriptGenerator {
     );
   }
 
+  /**
+   * Sort conditions so `{ Condition: ... }` references point at earlier
+   * declarations (#2069).
+   */
+  private sortConditions(conditions: ConditionIR[]): ConditionIR[] {
+    return topoSort(
+      conditions,
+      (c) => c.name,
+      (c) => [
+        ...collectDependencies(c.expression, (obj) =>
+          obj.__intrinsic === "ConditionRef" ? (obj.name as string) : null,
+        ),
+      ],
+    );
+  }
+
+  /**
+   * Render a condition reference as the condition's variable when the
+   * template declares it, or as a literal name string when it doesn't (an
+   * undeclared reference stays visible rather than breaking generation).
+   */
+  private conditionVarRef(name: string, ir: TemplateIR, importedSymbols: Set<string>): string {
+    const declared = (ir.conditions ?? []).some((c) => c.name === name);
+    return declared ? this.safeVarName(name, importedSymbols) : JSON.stringify(name);
+  }
+
+  /**
+   * Generate a condition declaration (#2069)
+   */
+  private generateCondition(condition: ConditionIR, ir: TemplateIR, importedSymbols: Set<string>): string {
+    const varName = this.safeVarName(condition.name, importedSymbols);
+    const exprStr = this.generateValue(condition.expression, ir, importedSymbols);
+    return `export const ${varName} = new Condition(${exprStr});`;
+  }
+
+  /**
+   * Generate an output declaration as stackOutput(...) (#2069)
+   */
+  private generateOutput(output: OutputIR, ir: TemplateIR, importedSymbols: Set<string>): string {
+    const varName = this.safeVarName(output.name, importedSymbols);
+
+    // A bare Ref envelope becomes Ref(<var>) — stackOutput takes an intrinsic
+    // or attribute reference, not the resource/parameter object itself.
+    let valueStr: string;
+    const value = output.value as Record<string, unknown> | null;
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && value.__intrinsic === "Ref" && !(value.name as string).startsWith("AWS::")) {
+      valueStr = `Ref(${this.safeVarName(value.name as string, importedSymbols)})`;
+    } else {
+      valueStr = this.generateValue(output.value, ir, importedSymbols);
+    }
+
+    const opts: string[] = [];
+    if (output.description) opts.push(`description: ${JSON.stringify(output.description)}`);
+    if (output.exportName !== undefined) {
+      opts.push(`exportName: ${this.generateValue(output.exportName, ir, importedSymbols)}`);
+    }
+    if (output.condition) {
+      opts.push(`condition: ${this.conditionVarRef(output.condition, ir, importedSymbols)}`);
+    }
+    // A literal output has no entity to derive its lexicon from.
+    if (typeof output.value === "string") {
+      opts.push(`lexicon: "aws"`);
+    }
+
+    if (opts.length > 0) {
+      return `export const ${varName} = stackOutput(${valueStr}, { ${opts.join(", ")} });`;
+    }
+    return `export const ${varName} = stackOutput(${valueStr});`;
+  }
+
   /**
    * Generate a parameter declaration
    */
@@ -264,6 +319,12 @@ export class CFGenerator implements TypeScriptGenerator {
     const { resourceClass } = parsed;
     const propsStr = this.generateProps(resource.properties, ir, importedSymbols);
 
+    // Resource-level Condition key → the attributes argument (#2069)
+    if (resource.condition) {
+      const condRef = this.conditionVarRef(resource.condition, ir, importedSymbols);
+      return `export const ${varName} = new ${resourceClass}(${propsStr}, { Condition: ${condRef} });`;
+    }
+
     if (propsStr === "{}") {
       return `export const ${varName} = new ${resourceClass}();`;
     }
@@ -344,9 +405,29 @@ export class CFGenerator implements TypeScriptGenerator {
 
       if (obj.__intrinsic === "If") {
         const condition = obj.condition as string;
+        const condRef = this.conditionVarRef(condition, ir, importedSymbols);
         const trueVal = this.generateValue(obj.valueIfTrue, ir, importedSymbols);
         const falseVal = this.generateValue(obj.valueIfFalse, ir, importedSymbols);
-        return `If("${condition}", ${trueVal}, ${falseVal})`;
+        return `If(${condRef}, ${trueVal}, ${falseVal})`;
+      }
+
+      if (obj.__intrinsic === "Equals") {
+        const left = this.generateValue(obj.left, ir, importedSymbols);
+        const right = this.generateValue(obj.right, ir, importedSymbols);
+        return `Equals(${left}, ${right})`;
+      }
+
+      if (obj.__intrinsic === "And" || obj.__intrinsic === "Or") {
+        const operands = (obj.conditions as unknown[]).map((c) => this.generateValue(c, ir, importedSymbols));
+        return `${obj.__intrinsic}(${operands.join(", ")})`;
+      }
+
+      if (obj.__intrinsic === "Not") {
+        return `Not(${this.generateValue(obj.condition, ir, importedSymbols)})`;
+      }
+
+      if (obj.__intrinsic === "ConditionRef") {
+        return this.conditionVarRef(obj.name as string, ir, importedSymbols);
       }
 
       if (obj.__intrinsic === "Join") {

package/src/import/parser.test.ts

@@ -198,3 +198,99 @@ describe("CFParser", () => {
     expect(vars.KEY).toBe("value");
   });
 });
+
+describe("CFParser conditions and outputs (#2069)", () => {
+  const parser = new CFParser();
+
+  const template = JSON.stringify({
+    AWSTemplateFormatVersion: "2010-09-09",
+    Parameters: { Cutover: { Type: "String", Default: "false" } },
+    Conditions: {
+      DoCutover: { "Fn::Equals": [{ Ref: "Cutover" }, "true"] },
+      NoCutover: { "Fn::Not": [{ Condition: "DoCutover" }] },
+    },
+    Resources: {
+      Rule: {
+        Type: "AWS::Logs::LogGroup",
+        Condition: "DoCutover",
+        Properties: { LogGroupName: { "Fn::If": ["DoCutover", "/on", "/off"] } },
+      },
+    },
+    Outputs: {
+      RuleName: { Condition: "DoCutover", Value: { Ref: "Rule" }, Description: "d", Export: { Name: "rule-name" } },
+      Plain: { Value: "literal" },
+    },
+  });
+
+  test("parses the Conditions section, Condition references included", () => {
+    const ir = parser.parse(template);
+    expect(ir.conditions).toHaveLength(2);
+    expect(ir.conditions![0]).toEqual({
+      name: "DoCutover",
+      expression: { __intrinsic: "Equals", left: { __intrinsic: "Ref", name: "Cutover" }, right: "true" },
+    });
+    expect(ir.conditions![1]).toEqual({
+      name: "NoCutover",
+      expression: { __intrinsic: "Not", condition: { __intrinsic: "ConditionRef", name: "DoCutover" } },
+    });
+  });
+
+  test("carries the resource-level Condition key", () => {
+    const ir = parser.parse(template);
+    expect(ir.resources[0].condition).toBe("DoCutover");
+  });
+
+  test("parses Outputs with Condition, Description, and Export", () => {
+    const ir = parser.parse(template);
+    expect(ir.outputs).toHaveLength(2);
+    expect(ir.outputs![0]).toEqual({
+      name: "RuleName",
+      value: { __intrinsic: "Ref", name: "Rule" },
+      description: "d",
+      exportName: "rule-name",
+      condition: "DoCutover",
+    });
+    expect(ir.outputs![1]).toEqual({
+      name: "Plain",
+      value: "literal",
+      description: undefined,
+      exportName: undefined,
+      condition: undefined,
+    });
+  });
+
+  test("a single-key Condition object in resource properties is NOT a condition reference", () => {
+    const ir = parser.parse(
+      JSON.stringify({
+        Resources: {
+          Role: {
+            Type: "AWS::IAM::Role",
+            Properties: {
+              Policy: { Condition: "not-a-ref" },
+            },
+          },
+        },
+      }),
+    );
+    expect(ir.resources[0].properties.Policy).toEqual({ Condition: "not-a-ref" });
+  });
+
+  test("names sections import cannot carry instead of dropping them silently", () => {
+    const ir = parser.parse(
+      JSON.stringify({
+        Resources: { R: { Type: "AWS::S3::Bucket" } },
+        Mappings: { M: {} },
+        Rules: { R1: {} },
+      }),
+    );
+    expect(ir.warnings).toEqual([
+      'Template section "Mappings" is not carried by import — it is dropped from the generated source',
+      'Template section "Rules" is not carried by import — it is dropped from the generated source',
+    ]);
+  });
+
+  test("no warnings for fully-carried templates", () => {
+    const ir = parser.parse(template);
+    expect(ir.warnings).toBeUndefined();
+  });
+});

package/src/import/parser.ts

@@ -3,6 +3,8 @@ import type {
   TemplateIR,
   ResourceIR,
   ParameterIR,
+  ConditionIR,
+  OutputIR,
 } from "@intentius/chant/import/parser";
 import { BaseValueParser } from "@intentius/chant/import/base-parser";
 import yaml from "js-yaml";
@@ -114,8 +116,19 @@ interface CFTemplate {
   AWSTemplateFormatVersion?: string;
   Description?: string;
   Parameters?: Record<string, CFParameter>;
+  Conditions?: Record<string, unknown>;
   Resources?: Record<string, CFResource>;
-  Outputs?: Record<string, unknown>;
+  Outputs?: Record<string, CFOutput>;
+}
+
+/**
+ * CloudFormation output
+ */
+interface CFOutput {
+  Value: unknown;
+  Description?: string;
+  Export?: { Name?: unknown };
+  Condition?: string;
 }
 
 /**
@@ -135,6 +148,7 @@ interface CFResource {
   Properties?: Record<string, unknown>;
   Metadata?: Record<string, unknown>;
   DependsOn?: string | string[];
+  Condition?: string;
 }
 
 /**
@@ -156,11 +170,17 @@ export class CFParser extends BaseValueParser implements TemplateParser {
     const template = parsed as CFTemplate;
 
     const parameters = this.parseParameters(template.Parameters ?? {});
+    const conditions = this.parseConditions(template.Conditions ?? {});
     const resources = this.parseResources(template.Resources ?? {});
+    const outputs = this.parseOutputs(template.Outputs ?? {});
+    const warnings = this.collectDroppedSectionWarnings(template as unknown as Record<string, unknown>);
 
     return {
       parameters,
+      conditions: conditions.length > 0 ? conditions : undefined,
       resources,
+      outputs: outputs.length > 0 ? outputs : undefined,
+      warnings: warnings.length > 0 ? warnings : undefined,
       metadata: {
         version: template.AWSTemplateFormatVersion ?? "2010-09-09",
         description: template.Description,
@@ -168,6 +188,64 @@ export class CFParser extends BaseValueParser implements TemplateParser {
     };
   }
 
+  /**
+   * Template sections import carries. Anything else is named in a warning
+   * rather than dropped silently (#2069).
+   */
+  private static readonly CARRIED_SECTIONS = new Set([
+    "AWSTemplateFormatVersion",
+    "Description",
+    "Parameters",
+    "Conditions",
+    "Resources",
+    "Outputs",
+  ]);
+
+  private collectDroppedSectionWarnings(template: Record<string, unknown>): string[] {
+    const warnings: string[] = [];
+    for (const key of Object.keys(template)) {
+      if (!CFParser.CARRIED_SECTIONS.has(key)) {
+        warnings.push(`Template section "${key}" is not carried by import — it is dropped from the generated source`);
+      }
+    }
+    return warnings;
+  }
+
+  /**
+   * Parse the Conditions section (#2069). Inside a condition expression the
+   * single-key `{ "Condition": "<name>" }` form references another declared
+   * condition; `inConditionExpression` scopes that dispatch to this section
+   * so a resource property that happens to hold a single-key `Condition`
+   * object is left alone.
+   */
+  private inConditionExpression = false;
+
+  private parseConditions(conditions: Record<string, unknown>): ConditionIR[] {
+    return Object.entries(conditions).map(([name, expression]) => {
+      this.inConditionExpression = true;
+      try {
+        return { name, expression: this.parseValue(expression) };
+      } finally {
+        this.inConditionExpression = false;
+      }
+    });
+  }
+
+  /**
+   * Parse the Outputs section (#2069).
+   */
+  private parseOutputs(outputs: Record<string, CFOutput>): OutputIR[] {
+    return Object.entries(outputs)
+      .filter(([_, output]) => typeof output === "object" && output !== null)
+      .map(([name, output]) => ({
+        name,
+        value: this.parseValue(output.Value),
+        description: output.Description,
+        exportName: output.Export?.Name !== undefined ? this.parseValue(output.Export.Name) : undefined,
+        condition: typeof output.Condition === "string" ? output.Condition : undefined,
+      }));
+  }
+
   /**
    * Parse parameters section
    */
@@ -192,6 +270,7 @@ export class CFParser extends BaseValueParser implements TemplateParser {
         type: resource.Type,
         properties: this.parseProperties(resource.Properties ?? {}),
         metadata: resource.Metadata,
+        condition: typeof resource.Condition === "string" ? resource.Condition : undefined,
       }));
   }
 
@@ -212,6 +291,12 @@ export class CFParser extends BaseValueParser implements TemplateParser {
    * CFN-specific intrinsic dispatch table.
    */
   protected dispatchIntrinsic(key: string, value: unknown, _obj: Record<string, unknown>): unknown | null {
+    // `{ "Condition": "<name>" }` — only valid inside the Conditions section
+    // (#2069); see parseConditions for the scoping.
+    if (key === "Condition" && this.inConditionExpression && typeof value === "string") {
+      return { __intrinsic: "ConditionRef", name: value };
+    }
+
     if (key === "Ref") {
       return { __intrinsic: "Ref", name: value };
     }

package/src/import/roundtrip-fixtures.test.ts

@@ -112,6 +112,56 @@ describe("parameters.json build roundtrip", () => {
   });
 });
 
+describe("with-conditions.json build roundtrip (#2069)", () => {
+  test("Conditions, Condition keys, and the conditioned output round-trip exactly", async () => {
+    const content = readFileSync(join(roundtripDir, "with-conditions.json"), "utf-8");
+    const source = JSON.parse(content);
+
+    const ir = parser.parse(content);
+    const files = generator.generate(ir);
+    const mainFile = files.find((f) => f.path === "main.ts")!;
+
+    // The generated source declares both conditions and keeps the references
+    expect(mainFile.content).toContain("new Condition(Equals(Ref(Cutover), \"true\"))");
+    expect(mainFile.content).toContain("new Condition(Not(DoCutover))");
+    expect(mainFile.content).toContain("{ Condition: DoCutover }");
+    expect(mainFile.content).toContain("stackOutput(Ref(Rule), { condition: DoCutover })");
+
+    const dir = mkdtempSync(join(import.meta.dirname, "../../.roundtrip-tmp-"));
+    try {
+      const srcDir = join(dir, "src");
+      mkdirSync(srcDir);
+      writeFileSync(join(srcDir, "main.ts"), mainFile.content);
+
+      const result = await build(srcDir, [awsSerializer]);
+      expect(result.errors).toHaveLength(0);
+
+      const template = JSON.parse(result.outputs.get("aws") as string);
+
+      // The Conditions section round-trips exactly, {Condition: ...} ref included
+      expect(template.Conditions).toEqual(source.Conditions);
+      // The resource keeps its Condition key and its Fn::If
+      expect(template.Resources.Rule.Condition).toBe("DoCutover");
+      expect(template.Resources.Rule.Properties.LogGroupName).toEqual(
+        source.Resources.Rule.Properties.LogGroupName,
+      );
+      // The conditioned output round-trips exactly
+      expect(template.Outputs).toEqual(source.Outputs);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("a section import cannot carry is named in a warning, never dropped silently", () => {
+    const template = JSON.parse(readFileSync(join(roundtripDir, "with-conditions.json"), "utf-8"));
+    template.Mappings = { RegionMap: { "us-east-1": { AMI: "ami-123" } } };
+    const ir = parser.parse(JSON.stringify(template));
+    expect(ir.warnings).toEqual([
+      'Template section "Mappings" is not carried by import — it is dropped from the generated source',
+    ]);
+  });
+});
+
 describe("SAM roundtrip fixtures", () => {
   const fixtures = readdirSync(samDir).filter(
     (f) => f.endsWith(".yaml") || f.endsWith(".yml"),

package/src/index.ts

@@ -1,6 +1,9 @@
 // Parameter
 export { Parameter } from "./parameter";
 
+// Condition (#2068) — the Conditions-section declarable
+export { Condition, isCondition, CONDITION_ENTITY_TYPE } from "./condition";
+
 // Default Tags
 export { defaultTags, isDefaultTags, DEFAULT_TAGS_MARKER } from "./default-tags";
 export type { DefaultTags, TagEntry } from "./default-tags";
@@ -105,6 +108,10 @@ export {
   Split,
   Base64,
   GetAZs,
+  Equals,
+  And,
+  Or,
+  Not,
   SubIntrinsic,
   RefIntrinsic,
   GetAttIntrinsic,
@@ -114,7 +121,12 @@ export {
   SplitIntrinsic,
   Base64Intrinsic,
   GetAZsIntrinsic,
+  EqualsIntrinsic,
+  AndIntrinsic,
+  OrIntrinsic,
+  NotIntrinsic,
 } from "./intrinsics";
+export type { ConditionOperand } from "./intrinsics";
 
 // Pseudo-parameters
 export {