@intentius/chant-lexicon-aws 0.0.4 → 0.0.5

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

@@ -1,8 +1,11 @@
 import { describe, test, expect } from "bun:test";
-import { readdirSync, readFileSync } from "fs";
+import { readdirSync, readFileSync, mkdtempSync, writeFileSync, mkdirSync, rmSync } from "fs";
 import { join } from "path";
 import { CFParser } from "./parser";
 import { CFGenerator } from "./generator";
+import { build } from "@intentius/chant/build";
+import { awsSerializer } from "../serializer";
+import * as awsLexicon from "../index";
 
 const parser = new CFParser();
 const generator = new CFGenerator();
@@ -10,6 +13,15 @@ const generator = new CFGenerator();
 const roundtripDir = join(import.meta.dir, "../testdata/roundtrip");
 const samDir = join(import.meta.dir, "../testdata/sam-fixtures");
 
+/** Extract imported symbols from `import { A, B } from "..."` statements */
+function extractImportedSymbols(code: string): string[] {
+  const match = code.match(/import\s*\{([^}]+)\}\s*from\s*/);
+  if (!match) return [];
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+
+const lexiconExports = new Set(Object.keys(awsLexicon));
+
 describe("CF roundtrip fixtures", () => {
   const fixtures = readdirSync(roundtripDir).filter((f) => f.endsWith(".json"));
 
@@ -36,20 +48,90 @@ describe("CF roundtrip fixtures", () => {
       expect(mainFile).toBeDefined();
 
       for (const name of resourceNames) {
-        const varName = name.charAt(0).toLowerCase() + name.slice(1);
-        expect(mainFile!.content).toContain(varName);
+        expect(mainFile!.content).toContain(name);
       }
 
       // If parameters exist, verify they appear in the output
       const paramNames = Object.keys(template.Parameters ?? {});
       for (const name of paramNames) {
-        const varName = name.charAt(0).toLowerCase() + name.slice(1);
-        expect(mainFile!.content).toContain(varName);
+        expect(mainFile!.content).toContain(name);
+      }
+
+      // Verify all imported symbols actually exist as exports from the lexicon
+      const importedSymbols = extractImportedSymbols(mainFile!.content);
+      for (const sym of importedSymbols) {
+        expect(lexiconExports.has(sym)).toBe(true);
       }
     });
   }
 });
 
+describe("parameters.json build roundtrip", () => {
+  test("generated code builds and produces correct CF Parameters", async () => {
+    const content = readFileSync(join(roundtripDir, "parameters.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")!;
+
+    // Write generated code to a temp directory inside the monorepo (so workspace packages resolve)
+    const dir = mkdtempSync(join(import.meta.dir, "../../.roundtrip-tmp-"));
+    try {
+    const srcDir = join(dir, "src");
+    mkdirSync(srcDir);
+
+    writeFileSync(join(srcDir, "_.ts"), [
+      `export * from "@intentius/chant-lexicon-aws";`,
+      `import * as core from "@intentius/chant";`,
+      `export const $ = core.barrel(import.meta.dir);`,
+    ].join("\n"));
+
+    // Rewrite the import to use the barrel
+    const rewritten = mainFile.content.replace(
+      /import \{[^}]+\} from "@intentius\/chant-lexicon-aws";/,
+      `import * as _ from "./_";`,
+    );
+    // Replace bare symbol references with _.Symbol
+    const symbols = extractImportedSymbols(mainFile.content);
+    let code = rewritten;
+    for (const sym of symbols) {
+      code = code.replace(new RegExp(`\\bnew ${sym}\\(`, "g"), `new _.${sym}(`);
+      code = code.replace(new RegExp(`(?<!\\.)\\b${sym}\``, "g"), `_.${sym}\``);
+      code = code.replace(new RegExp(`(?<!\\.)\\b${sym}\\(`, "g"), `_.${sym}(`);
+      code = code.replace(new RegExp(`(?<!\\.)\\b${sym}\\.`, "g"), `_.${sym}.`);
+    }
+    writeFileSync(join(srcDir, "main.ts"), code);
+
+    // Build and verify
+    const result = await build(srcDir, [awsSerializer]);
+    expect(result.errors).toHaveLength(0);
+
+    const template = JSON.parse(result.outputs.get("aws")!);
+
+    // Verify parameters round-tripped correctly (names preserved as-is)
+    for (const [name, param] of Object.entries(source.Parameters ?? {})) {
+      const p = param as Record<string, unknown>;
+      expect(template.Parameters[name]).toBeDefined();
+      expect(template.Parameters[name].Type).toBe(p.Type);
+      if (p.Description) {
+        expect(template.Parameters[name].Description).toBe(p.Description);
+      }
+      if (p.Default !== undefined) {
+        expect(template.Parameters[name].Default).toBe(p.Default);
+      }
+    }
+
+    // Verify resources round-tripped (names preserved as-is)
+    for (const name of Object.keys(source.Resources ?? {})) {
+      expect(template.Resources[name]).toBeDefined();
+    }
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
 describe("SAM roundtrip fixtures", () => {
   const fixtures = readdirSync(samDir).filter(
     (f) => f.endsWith(".yaml") || f.endsWith(".yml"),

package/src/import/roundtrip.test.ts

@@ -25,6 +25,7 @@ describe("CloudFormation round-trip", () => {
 
     expect(files[0].content).toContain("Bucket");
     expect(files[0].content).toContain('bucketName: "my-bucket"');
+    expect(files[0].content).toContain("export const MyBucket");
   });
 
   test("round-trips template with parameters", () => {
@@ -51,8 +52,8 @@ describe("CloudFormation round-trip", () => {
     const files = generator.generate(ir);
 
     expect(files[0].content).toContain("Parameter");
-    expect(files[0].content).toContain("environment");
-    expect(files[0].content).toContain("bucketName: environment");
+    expect(files[0].content).toContain("Environment");
+    expect(files[0].content).toContain("bucketName: Ref(Environment)");
   });
 
   test("round-trips template with Fn::Sub", () => {
@@ -114,7 +115,7 @@ describe("CloudFormation round-trip", () => {
 
     expect(files[0].content).toContain("Role");
     expect(files[0].content).toContain("Function");
-    expect(files[0].content).toContain("lambdaRole.arn");
+    expect(files[0].content).toContain("LambdaRole.arn");
   });
 
   test("round-trips complex nested properties", () => {
@@ -147,8 +148,8 @@ describe("CloudFormation round-trip", () => {
     const files = generator.generate(ir);
 
     expect(files[0].content).toContain("Function");
-    expect(files[0].content).toContain("environment");
-    expect(files[0].content).toContain("vpcConfig");
+    expect(files[0].content).toContain("environment:");
+    expect(files[0].content).toContain("vpcConfig:");
   });
 
   test("round-trips empty template", () => {

package/src/index.ts

@@ -1,3 +1,6 @@
+// Parameter
+export { Parameter } from "./parameter";
+
 // Serializer
 export { awsSerializer } from "./serializer";
 
@@ -5,11 +8,13 @@ export { awsSerializer } from "./serializer";
 export { nestedStack, isNestedStackInstance, NestedStackOutputRef, isNestedStackOutputRef, NESTED_STACK_MARKER } from "./nested-stack";
 export type { NestedStackOptions, NestedStackInstance } from "./nested-stack";
 
-// Re-export core child project and stack output primitives
+// Re-export core child project, stack output, and lexicon output primitives
 export { isChildProject, CHILD_PROJECT_MARKER } from "@intentius/chant/child-project";
 export type { ChildProjectInstance } from "@intentius/chant/child-project";
 export { stackOutput, isStackOutput, STACK_OUTPUT_MARKER } from "@intentius/chant/stack-output";
 export type { StackOutput } from "@intentius/chant/stack-output";
+export { output, isLexiconOutput } from "@intentius/chant/lexicon-output";
+export type { LexiconOutput } from "@intentius/chant/lexicon-output";
 
 // Plugin
 export { awsPlugin } from "./plugin";
@@ -24,6 +29,7 @@ export {
   Select,
   Split,
   Base64,
+  GetAZs,
   SubIntrinsic,
   RefIntrinsic,
   GetAttIntrinsic,
@@ -32,6 +38,7 @@ export {
   SelectIntrinsic,
   SplitIntrinsic,
   Base64Intrinsic,
+  GetAZsIntrinsic,
 } from "./intrinsics";
 
 // Pseudo-parameters

package/src/intrinsics.ts

@@ -221,3 +221,30 @@ export class Base64Intrinsic implements Intrinsic {
 export function Base64(value: string | Intrinsic): Base64Intrinsic {
   return new Base64Intrinsic(value);
 }
+
+/**
+ * Fn::GetAZs intrinsic function
+ * Returns a list of Availability Zones for a region
+ */
+export class GetAZsIntrinsic implements Intrinsic {
+  readonly [INTRINSIC_MARKER] = true as const;
+  private region: string | Intrinsic;
+
+  constructor(region: string | Intrinsic = "") {
+    this.region = region;
+  }
+
+  toJSON(): { "Fn::GetAZs": unknown } {
+    const regionValue = typeof this.region === "string"
+      ? this.region
+      : (this.region as Intrinsic & { toJSON(): unknown }).toJSON();
+    return { "Fn::GetAZs": regionValue };
+  }
+}
+
+/**
+ * Create a GetAZs intrinsic
+ */
+export function GetAZs(region?: string | Intrinsic): GetAZsIntrinsic {
+  return new GetAZsIntrinsic(region);
+}

package/src/parameter.ts

@@ -0,0 +1,16 @@
+import { DECLARABLE_MARKER, type CoreParameter } from "@intentius/chant/declarable";
+
+export class Parameter implements CoreParameter {
+  readonly [DECLARABLE_MARKER] = true as const;
+  readonly lexicon = "aws";
+  readonly entityType = "AWS::CloudFormation::Parameter";
+  readonly parameterType: string;
+  readonly description?: string;
+  readonly defaultValue?: unknown;
+
+  constructor(type: string, options?: { description?: string; defaultValue?: unknown }) {
+    this.parameterType = type;
+    this.description = options?.description;
+    this.defaultValue = options?.defaultValue;
+  }
+}

package/src/plugin.test.ts

@@ -36,7 +36,7 @@ describe("awsPlugin", () => {
 
   test("returns intrinsics", () => {
     const intrinsics = awsPlugin.intrinsics!();
-    expect(intrinsics.length).toBe(8);
+    expect(intrinsics.length).toBe(9);
     const names = intrinsics.map((i) => i.name);
     expect(names).toContain("Sub");
     expect(names).toContain("Ref");

package/src/plugin.ts

@@ -35,6 +35,7 @@ export const awsPlugin: LexiconPlugin = {
       { name: "Select", description: "Fn::Select — select value by index" },
       { name: "Split", description: "Fn::Split — split string by delimiter" },
       { name: "Base64", description: "Fn::Base64 — encode to Base64" },
+      { name: "GetAZs", description: "Fn::GetAZs — list Availability Zones" },
     ];
   },
 

package/src/serializer.test.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect } from "bun:test";
 import { awsSerializer } from "./serializer";
 import { AttrRef } from "@intentius/chant/attrref";
-import { DECLARABLE_MARKER, type Declarable, type CoreParameter } from "@intentius/chant/declarable";
+import { DECLARABLE_MARKER, type Declarable } from "@intentius/chant/declarable";
 import { LexiconOutput } from "@intentius/chant/lexicon-output";
 import { Sub } from "./intrinsics";
 import { AWS } from "./pseudo";
@@ -10,6 +10,7 @@ import { stackOutput } from "@intentius/chant/stack-output";
 import { createResource } from "@intentius/chant/runtime";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import type { BuildResult } from "@intentius/chant/build";
+import { Parameter } from "./parameter";
 
 // Mock S3 Bucket for testing
 class MockBucket implements Declarable {
@@ -25,22 +26,6 @@ class MockBucket implements Declarable {
   }
 }
 
-// Mock Parameter for testing
-class MockParameter implements CoreParameter {
-  readonly [DECLARABLE_MARKER] = true as const;
-  readonly lexicon = "aws";
-  readonly entityType = "AWS::CloudFormation::Parameter";
-  readonly parameterType: string;
-  readonly description?: string;
-  readonly defaultValue?: unknown;
-
-  constructor(type: string, options: { description?: string; defaultValue?: unknown } = {}) {
-    this.parameterType = type;
-    this.description = options.description;
-    this.defaultValue = options.defaultValue;
-  }
-}
-
 describe("awsSerializer", () => {
   test("has correct name", () => {
     expect(awsSerializer.name).toBe("aws");
@@ -84,7 +69,7 @@ describe("awsSerializer.serialize", () => {
 
   test("serializes parameters", () => {
     const entities = new Map<string, Declarable>();
-    entities.set("Environment", new MockParameter("String", {
+    entities.set("Environment", new Parameter("String", {
       description: "Environment name",
       defaultValue: "dev",
     }));
@@ -139,7 +124,7 @@ describe("awsSerializer.serialize", () => {
 
   test("handles resources and parameters together", () => {
     const entities = new Map<string, Declarable>();
-    entities.set("Env", new MockParameter("String"));
+    entities.set("Env", new Parameter("String"));
     entities.set("MyBucket", new MockBucket({ bucketName: "bucket" }));
 
     const output = awsSerializer.serialize(entities);