@intentius/chant-lexicon-aws 0.0.4 → 0.0.6

package/src/import/generator.test.ts

@@ -34,7 +34,7 @@ describe("CFGenerator", () => {
     const files = generator.generate(ir);
 
     expect(files[0].content).toContain("import { Bucket }");
-    expect(files[0].content).toContain("export const myBucket = new Bucket({");
+    expect(files[0].content).toContain("export const MyBucket = new Bucket({");
     expect(files[0].content).toContain('bucketName: "my-bucket"');
   });
 
@@ -57,7 +57,7 @@ describe("CFGenerator", () => {
     const files = generator.generate(ir);
 
     expect(files[0].content).toContain("import { Function }");
-    expect(files[0].content).toContain("export const myFunction = new Function({");
+    expect(files[0].content).toContain("export const MyFunction = new Function({");
     expect(files[0].content).toContain('functionName: "my-function"');
     expect(files[0].content).toContain('runtime: "nodejs18.x"');
   });
@@ -78,7 +78,7 @@ describe("CFGenerator", () => {
 
     const files = generator.generate(ir);
 
-    expect(files[0].content).toContain("bucketName: bucketName");
+    expect(files[0].content).toContain("bucketName: Ref(BucketName)");
   });
 
   test("generates GetAtt as property access", () => {
@@ -102,7 +102,7 @@ describe("CFGenerator", () => {
 
     const files = generator.generate(ir);
 
-    expect(files[0].content).toContain("sourceArn: sourceBucket.arn");
+    expect(files[0].content).toContain("sourceArn: SourceBucket.arn");
   });
 
   test("generates Sub as tagged template", () => {
@@ -173,9 +173,120 @@ describe("CFGenerator", () => {
     const files = generator.generate(ir);
     const content = files[0].content;
 
-    const sourcePos = content.indexOf("sourceBucket");
-    const depPos = content.indexOf("dependentBucket");
+    const sourcePos = content.indexOf("SourceBucket");
+    const depPos = content.indexOf("DependentBucket");
 
     expect(sourcePos).toBeLessThan(depPos);
   });
+
+  test("Sub template refs create topo sort dependencies", () => {
+    const ir: TemplateIR = {
+      parameters: [],
+      resources: [
+        {
+          logicalId: "DependentResource",
+          type: "AWS::S3::Bucket",
+          properties: {
+            BucketName: { __intrinsic: "Sub", template: "${SourceBucket}-copy" },
+          },
+        },
+        {
+          logicalId: "SourceBucket",
+          type: "AWS::S3::Bucket",
+          properties: {},
+        },
+      ],
+    };
+
+    const files = generator.generate(ir);
+    const content = files[0].content;
+
+    const sourcePos = content.indexOf("SourceBucket");
+    const depPos = content.indexOf("DependentResource");
+
+    expect(sourcePos).toBeLessThan(depPos);
+  });
+
+  test("generates GetAZs with no argument", () => {
+    const ir: TemplateIR = {
+      parameters: [],
+      resources: [
+        {
+          logicalId: "MyBucket",
+          type: "AWS::S3::Bucket",
+          properties: {
+            BucketName: { __intrinsic: "GetAZs", region: "" },
+          },
+        },
+      ],
+    };
+
+    const files = generator.generate(ir);
+
+    expect(files[0].content).toContain("GetAZs()");
+    expect(files[0].content).toContain("import { GetAZs");
+  });
+
+  test("generates GetAZs with region argument", () => {
+    const ir: TemplateIR = {
+      parameters: [],
+      resources: [
+        {
+          logicalId: "MyBucket",
+          type: "AWS::S3::Bucket",
+          properties: {
+            BucketName: { __intrinsic: "GetAZs", region: "us-east-1" },
+          },
+        },
+      ],
+    };
+
+    const files = generator.generate(ir);
+
+    expect(files[0].content).toContain('GetAZs("us-east-1")');
+  });
+
+  test("escapes backticks in Sub template", () => {
+    const ir: TemplateIR = {
+      parameters: [],
+      resources: [
+        {
+          logicalId: "MyBucket",
+          type: "AWS::S3::Bucket",
+          properties: {
+            BucketName: { __intrinsic: "Sub", template: "stats `field-name` query" },
+          },
+        },
+      ],
+    };
+
+    const files = generator.generate(ir);
+
+    expect(files[0].content).toContain("\\`field-name\\`");
+  });
+
+  test("generates nested GetAtt attribute with GetAtt function call", () => {
+    const ir: TemplateIR = {
+      parameters: [],
+      resources: [
+        {
+          logicalId: "ELB",
+          type: "AWS::ElasticLoadBalancing::LoadBalancer",
+          properties: {},
+        },
+        {
+          logicalId: "MyBucket",
+          type: "AWS::S3::Bucket",
+          properties: {
+            BucketName: { __intrinsic: "GetAtt", logicalId: "ELB", attribute: "SourceSecurityGroup.OwnerAlias" },
+          },
+        },
+      ],
+    };
+
+    const files = generator.generate(ir);
+
+    expect(files[0].content).toContain('GetAtt(ELB, "SourceSecurityGroup.OwnerAlias")');
+    expect(files[0].content).toContain("import { GetAtt");
+  });
 });

package/src/import/generator.ts

@@ -2,24 +2,46 @@ import type { TemplateIR, ResourceIR, ParameterIR } from "@intentius/chant/impor
 import type { TypeScriptGenerator, GeneratedFile } from "@intentius/chant/import/generator";
 import { topoSort } from "@intentius/chant/codegen/topo-sort";
 import { hasIntrinsicInValue, irUsesIntrinsic, collectDependencies } from "@intentius/chant/import/ir-utils";
+import { join } from "path";
 
 /**
  * TypeScript code generator for CloudFormation templates
  */
 export class CFGenerator implements TypeScriptGenerator {
+  private typeToClass: Map<string, string>;
+  private allClassNames: Set<string>;
+
+  constructor() {
+    // Build reverse lookup from dist/meta.json: resourceType → className
+    const metaPath = join(import.meta.dir, "../../dist/meta.json");
+    const meta: Record<string, { resourceType: string; kind: string }> =
+      require(metaPath);
+    this.typeToClass = new Map();
+    this.allClassNames = new Set();
+    for (const [className, entry] of Object.entries(meta)) {
+      if (entry.kind === "resource" && !className.includes("_")) {
+        this.typeToClass.set(entry.resourceType, className);
+        this.allClassNames.add(className);
+      }
+    }
+  }
+
   /**
    * Generate TypeScript files from intermediate representation
    */
   generate(ir: TemplateIR): GeneratedFile[] {
     const lines: string[] = [];
 
+    // Collect the set of imported class names so we can detect variable name conflicts
+    const importedSymbols = this.collectImportedSymbols(ir);
+
     // Generate imports
     lines.push(this.generateImports(ir));
     lines.push("");
 
     // Generate parameters
     for (const param of ir.parameters) {
-      lines.push(this.generateParameter(param));
+      lines.push(this.generateParameter(param, importedSymbols));
     }
 
     if (ir.parameters.length > 0) {
@@ -29,7 +51,7 @@ export class CFGenerator implements TypeScriptGenerator {
     // Generate resources in dependency order
     const sortedResources = this.sortByDependencies(ir.resources);
     for (const resource of sortedResources) {
-      lines.push(this.generateResource(resource, ir));
+      lines.push(this.generateResource(resource, ir, importedSymbols));
     }
 
     return [
@@ -40,6 +62,31 @@ export class CFGenerator implements TypeScriptGenerator {
     ];
   }
 
+  /**
+   * Collect the set of symbols that will be imported (class names, intrinsics, etc.)
+   */
+  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;
+    for (const name of intrinsics) {
+      if (irUsesIntrinsic(ir, name)) symbols.add(name);
+    }
+    if (this.needsAWSPseudo(ir)) symbols.add("AWS");
+    for (const resource of ir.resources) {
+      const parsed = this.parseResourceType(resource.type);
+      if (parsed) symbols.add(parsed.resourceClass);
+    }
+    return symbols;
+  }
+
+  /**
+   * Resolve a logical ID to a safe variable name, suffixing with _ if it conflicts with an imported symbol
+   */
+  private safeVarName(name: string, importedSymbols: Set<string>): string {
+    return importedSymbols.has(name) ? name + "_" : name;
+  }
+
   /**
    * Generate import statements
    */
@@ -54,24 +101,21 @@ export class CFGenerator implements TypeScriptGenerator {
     }
 
     // Check for intrinsics
-    const needsSub = irUsesIntrinsic(ir, "Sub");
-    const needsRef = irUsesIntrinsic(ir, "Ref");
-    const needsIf = irUsesIntrinsic(ir, "If");
-    const needsJoin = irUsesIntrinsic(ir, "Join");
-
-    if (needsSub) imports.add("Sub");
-    if (needsRef) imports.add("Ref");
-    if (needsIf) imports.add("If");
-    if (needsJoin) imports.add("Join");
+    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
+    // Collect service imports (skip unknown resource types)
     for (const resource of ir.resources) {
-      const { service, resourceClass } = this.parseResourceType(resource.type);
+      const parsed = this.parseResourceType(resource.type);
+      if (!parsed) continue;
+      const { service, resourceClass } = parsed;
       if (!serviceImports.has(service)) {
         serviceImports.set(service, new Set());
       }
@@ -98,14 +142,16 @@ export class CFGenerator implements TypeScriptGenerator {
   }
 
   /**
-   * Parse AWS resource type into service and class names
+   * Parse AWS resource type into service and class names.
+   * Returns null for unknown/unsupported types (Custom::*, third-party, etc.)
    */
-  private parseResourceType(type: string): { service: string; resourceClass: string } {
-    // AWS::S3::Bucket -> { service: "s3", resourceClass: "Bucket" }
+  private parseResourceType(type: string): { service: string; resourceClass: string } | null {
+    const className = this.typeToClass.get(type);
+    if (!className) return null;
     const parts = type.split("::");
     return {
       service: parts[1]?.toLowerCase() ?? "unknown",
-      resourceClass: parts[2] ?? "Unknown",
+      resourceClass: className,
     };
   }
 
@@ -153,37 +199,67 @@ export class CFGenerator implements TypeScriptGenerator {
    * Sort resources by dependencies
    */
   private sortByDependencies(resources: ResourceIR[]): ResourceIR[] {
+    const resourceIds = new Set(resources.map((r) => r.logicalId));
     return topoSort(
       resources,
       (r) => r.logicalId,
-      (r) => [...collectDependencies(r.properties, (obj) => {
-        if (obj.__intrinsic === "Ref") {
-          const name = obj.name as string;
-          return name.startsWith("AWS::") ? null : name;
-        }
-        if (obj.__intrinsic === "GetAtt") {
-          return obj.logicalId as string;
-        }
-        return null;
-      })],
+      (r) => {
+        const extraDeps = new Set<string>();
+        const deps = collectDependencies(r.properties, (obj) => {
+          if (obj.__intrinsic === "Ref") {
+            const name = obj.name as string;
+            return name.startsWith("AWS::") ? null : name;
+          }
+          if (obj.__intrinsic === "GetAtt") {
+            return obj.logicalId as string;
+          }
+          if (obj.__intrinsic === "Sub") {
+            const tpl = obj.template as string;
+            const re = /\$\{([^}]+)\}/g;
+            let m;
+            while ((m = re.exec(tpl)) !== null) {
+              const expr = m[1];
+              if (!expr.startsWith("AWS::")) {
+                const id = expr.split(".")[0];
+                if (resourceIds.has(id)) extraDeps.add(id);
+              }
+            }
+            return null;
+          }
+          return null;
+        });
+        for (const d of extraDeps) deps.add(d);
+        return [...deps];
+      },
     );
   }
 
   /**
    * Generate a parameter declaration
    */
-  private generateParameter(param: ParameterIR): string {
-    const varName = this.toVariableName(param.name);
+  private generateParameter(param: ParameterIR, importedSymbols: Set<string>): string {
+    const varName = this.safeVarName(param.name, importedSymbols);
+    const opts: string[] = [];
+    if (param.description) opts.push(`description: ${JSON.stringify(param.description)}`);
+    if (param.defaultValue !== undefined) opts.push(`defaultValue: ${JSON.stringify(param.defaultValue)}`);
+    if (opts.length > 0) {
+      return `export const ${varName} = new Parameter("${param.type}", { ${opts.join(", ")} });`;
+    }
     return `export const ${varName} = new Parameter("${param.type}");`;
   }
 
   /**
-   * Generate a resource declaration
+   * Generate a resource declaration, or a comment if the type is unknown
    */
-  private generateResource(resource: ResourceIR, ir: TemplateIR): string {
-    const varName = this.toVariableName(resource.logicalId);
-    const { resourceClass } = this.parseResourceType(resource.type);
-    const propsStr = this.generateProps(resource.properties, ir);
+  private generateResource(resource: ResourceIR, ir: TemplateIR, importedSymbols: Set<string>): string {
+    const parsed = this.parseResourceType(resource.type);
+    if (!parsed) {
+      const varName = this.safeVarName(resource.logicalId, importedSymbols);
+      return `// Unsupported type: ${resource.type}\nexport const ${varName} = "${resource.logicalId}";`;
+    }
+    const varName = this.safeVarName(resource.logicalId, importedSymbols);
+    const { resourceClass } = parsed;
+    const propsStr = this.generateProps(resource.properties, ir, importedSymbols);
 
     if (propsStr === "{}") {
       return `export const ${varName} = new ${resourceClass}();`;
@@ -195,14 +271,14 @@ export class CFGenerator implements TypeScriptGenerator {
   /**
    * Generate property object as TypeScript
    */
-  private generateProps(props: Record<string, unknown>, ir: TemplateIR): string {
+  private generateProps(props: Record<string, unknown>, ir: TemplateIR, importedSymbols: Set<string>): string {
     if (Object.keys(props).length === 0) {
       return "{}";
     }
 
     const entries = Object.entries(props).map(([key, value]) => {
       const propName = this.toPropName(key);
-      const valueStr = this.generateValue(value, ir);
+      const valueStr = this.generateValue(value, ir, importedSymbols);
       return `  ${propName}: ${valueStr}`;
     });
 
@@ -212,7 +288,7 @@ export class CFGenerator implements TypeScriptGenerator {
   /**
    * Generate a value as TypeScript
    */
-  private generateValue(value: unknown, ir: TemplateIR): string {
+  private generateValue(value: unknown, ir: TemplateIR, importedSymbols: Set<string> = new Set()): string {
     if (value === null || value === undefined) {
       return "undefined";
     }
@@ -226,7 +302,7 @@ export class CFGenerator implements TypeScriptGenerator {
     }
 
     if (Array.isArray(value)) {
-      const items = value.map((item) => this.generateValue(item, ir));
+      const items = value.map((item) => this.generateValue(item, ir, importedSymbols));
       return `[${items.join(", ")}]`;
     }
 
@@ -239,37 +315,72 @@ export class CFGenerator implements TypeScriptGenerator {
         if (name.startsWith("AWS::")) {
           return `AWS.${this.pseudoParamName(name)}`;
         }
-        return this.toVariableName(name);
+        const varName = this.safeVarName(name, importedSymbols);
+        // Parameters need Ref() — bare variable would pass the Parameter object, not its value
+        const isParam = ir.parameters.some((p) => p.name === name);
+        if (isParam) {
+          return `Ref(${varName})`;
+        }
+        return varName;
       }
 
       if (obj.__intrinsic === "GetAtt") {
         const logicalId = obj.logicalId as string;
         const attribute = obj.attribute as string;
-        const varName = this.toVariableName(logicalId);
+        const varName = this.safeVarName(logicalId, importedSymbols);
+        if (attribute.includes(".")) {
+          return `GetAtt(${varName}, "${attribute}")`;
+        }
         const attrName = this.toPropName(attribute);
         return `${varName}.${attrName}`;
       }
 
       if (obj.__intrinsic === "Sub") {
-        return this.generateSubIntrinsic(obj.template as string, ir);
+        return this.generateSubIntrinsic(obj.template as string, obj.variables as Record<string, unknown> | undefined, ir, importedSymbols);
       }
 
       if (obj.__intrinsic === "If") {
         const condition = obj.condition as string;
-        const trueVal = this.generateValue(obj.valueIfTrue, ir);
-        const falseVal = this.generateValue(obj.valueIfFalse, ir);
+        const trueVal = this.generateValue(obj.valueIfTrue, ir, importedSymbols);
+        const falseVal = this.generateValue(obj.valueIfFalse, ir, importedSymbols);
         return `If("${condition}", ${trueVal}, ${falseVal})`;
       }
 
       if (obj.__intrinsic === "Join") {
         const delimiter = JSON.stringify(obj.delimiter);
-        const values = (obj.values as unknown[]).map((v) => this.generateValue(v, ir));
+        const values = (obj.values as unknown[]).map((v) => this.generateValue(v, ir, importedSymbols));
         return `Join(${delimiter}, [${values.join(", ")}])`;
       }
 
-      // Regular object
+      if (obj.__intrinsic === "Select") {
+        const index = obj.index as number;
+        const values = (obj.values as unknown[]).map((v) => this.generateValue(v, ir, importedSymbols));
+        return `Select(${index}, [${values.join(", ")}])`;
+      }
+
+      if (obj.__intrinsic === "Split") {
+        const delimiter = JSON.stringify(obj.delimiter);
+        const source = this.generateValue(obj.source, ir, importedSymbols);
+        return `Split(${delimiter}, ${source})`;
+      }
+
+      if (obj.__intrinsic === "Base64") {
+        const value = this.generateValue(obj.value, ir, importedSymbols);
+        return `Base64(${value})`;
+      }
+
+      if (obj.__intrinsic === "GetAZs") {
+        const region = obj.region;
+        if (region === undefined || region === "" || region === null) {
+          return "GetAZs()";
+        }
+        return `GetAZs(${this.generateValue(region, ir, importedSymbols)})`;
+      }
+
+      // Regular object — quote keys that aren't valid JS identifiers
       const entries = Object.entries(obj).map(([key, val]) => {
-        return `${key}: ${this.generateValue(val, ir)}`;
+        const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+        return `${safeKey}: ${this.generateValue(val, ir, importedSymbols)}`;
       });
       return `{ ${entries.join(", ")} }`;
     }
@@ -280,7 +391,9 @@ export class CFGenerator implements TypeScriptGenerator {
   /**
    * Generate Sub intrinsic as tagged template literal
    */
-  private generateSubIntrinsic(template: string, ir: TemplateIR): string {
+  private generateSubIntrinsic(template: string, variables: Record<string, unknown> | undefined, ir: TemplateIR, importedSymbols: Set<string>): string {
+    const escapePart = (s: string) => s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+
     // Parse ${...} interpolations from the Sub template
     const parts: string[] = [];
     const expressions: string[] = [];
@@ -295,13 +408,21 @@ export class CFGenerator implements TypeScriptGenerator {
       const expr = match[1];
       if (expr.startsWith("AWS::")) {
         expressions.push(`AWS.${this.pseudoParamName(expr)}`);
+      } else if (variables && expr in variables) {
+        expressions.push(this.generateValue(variables[expr], ir, importedSymbols));
       } else if (expr.includes(".")) {
-        const [logicalId, attr] = expr.split(".");
-        const varName = this.toVariableName(logicalId);
-        const attrName = this.toPropName(attr);
-        expressions.push(`${varName}.${attrName}`);
+        const dotIdx = expr.indexOf(".");
+        const logicalId = expr.slice(0, dotIdx);
+        const attr = expr.slice(dotIdx + 1);
+        const varName = this.safeVarName(logicalId, importedSymbols);
+        if (attr.includes(".")) {
+          expressions.push(`GetAtt(${varName}, "${attr}")`);
+        } else {
+          const attrName = this.toPropName(attr);
+          expressions.push(`${varName}.${attrName}`);
+        }
       } else {
-        expressions.push(this.toVariableName(expr));
+        expressions.push(this.safeVarName(expr, importedSymbols));
       }
 
       currentPos = match.index + match[0].length;
@@ -310,12 +431,12 @@ export class CFGenerator implements TypeScriptGenerator {
     parts.push(template.slice(currentPos));
 
     if (expressions.length === 0) {
-      return `Sub\`${template}\``;
+      return `Sub\`${escapePart(template)}\``;
     }
 
     let result = "Sub`";
     for (let i = 0; i < parts.length; i++) {
-      result += parts[i];
+      result += escapePart(parts[i]);
       if (i < expressions.length) {
         result += `\${${expressions[i]}}`;
       }
@@ -334,14 +455,9 @@ export class CFGenerator implements TypeScriptGenerator {
   }
 
   /**
-   * Convert a logical name to a valid TypeScript variable name
-   */
-  private toVariableName(name: string): string {
-    return name.charAt(0).toLowerCase() + name.slice(1);
-  }
-
-  /**
-   * Convert a property name to camelCase
+   * Convert a property name to camelCase (lowercase first char).
+   * Used for resource property access (e.g., GetAtt attribute names)
+   * which matches chant's camelCase property convention.
    */
   private toPropName(name: string): string {
     return name.charAt(0).toLowerCase() + name.slice(1);

package/src/import/parser.ts

@@ -221,7 +221,7 @@ export class CFParser extends BaseValueParser implements TemplateParser {
         return { __intrinsic: "GetAtt", logicalId: value[0], attribute: value[1] };
       }
       if (typeof value === "string") {
-        const [logicalId, attribute] = value.split(".");
+        const [logicalId, attribute] = value.split(".", 2);
         return { __intrinsic: "GetAtt", logicalId, attribute };
       }
     }