@intentius/chant-lexicon-aws 0.0.4 → 0.0.6

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"));
 
@@ -24,32 +36,81 @@ describe("CF roundtrip fixtures", () => {
       // Verify at least one file was generated
       expect(files.length).toBeGreaterThanOrEqual(1);
 
-      // Verify barrel/main file exists
-      const hasBarrel = files.some(
-        (f) => f.path === "main.ts" || f.path === "_.ts",
-      );
-      expect(hasBarrel).toBe(true);
+      // Verify main file exists
+      const hasMain = files.some((f) => f.path === "main.ts");
+      expect(hasMain).toBe(true);
 
       // Verify resource count: each resource should be represented in generated output
       const resourceNames = Object.keys(template.Resources ?? {});
-      const mainFile = files.find((f) => f.path === "main.ts" || f.path === "_.ts");
+      const mainFile = files.find((f) => f.path === "main.ts");
       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);
+
+    // Write generated code as-is (direct imports)
+    writeFileSync(join(srcDir, "main.ts"), mainFile.content);
+
+    // 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" },
     ];
   },
 
@@ -53,7 +54,6 @@ export const awsPlugin: LexiconPlugin = {
 
   initTemplates(): Record<string, string> {
     return {
-      "_.ts": `export * from "./config";\n`,
       "config.ts": `/**
  * Shared bucket configuration — encryption, versioning, public access
  */
@@ -92,29 +92,29 @@ export const versioningEnabled = new aws.VersioningConfiguration({
  * Data bucket — primary storage with encryption and versioning
  */
 
-import * as aws from "@intentius/chant-lexicon-aws";
-import * as _ from "./_";
+import { Bucket, Sub, AWS } from "@intentius/chant-lexicon-aws";
+import { versioningEnabled, bucketEncryption, publicAccessBlock } from "./config";
 
-export const dataBucket = new aws.Bucket({
-  bucketName: aws.Sub\`\${aws.AWS.StackName}-data\`,
-  versioningConfiguration: _.versioningEnabled,
-  bucketEncryption: _.bucketEncryption,
-  publicAccessBlockConfiguration: _.publicAccessBlock,
+export const dataBucket = new Bucket({
+  bucketName: Sub\`\${AWS.StackName}-data\`,
+  versioningConfiguration: versioningEnabled,
+  bucketEncryption: bucketEncryption,
+  publicAccessBlockConfiguration: publicAccessBlock,
 });
 `,
       "logs-bucket.ts": `/**
  * Logs bucket — log delivery with encryption and versioning
  */
 
-import * as aws from "@intentius/chant-lexicon-aws";
-import * as _ from "./_";
+import { Bucket, Sub, AWS } from "@intentius/chant-lexicon-aws";
+import { versioningEnabled, bucketEncryption, publicAccessBlock } from "./config";
 
-export const logsBucket = new aws.Bucket({
-  bucketName: aws.Sub\`\${aws.AWS.StackName}-logs\`,
+export const logsBucket = new Bucket({
+  bucketName: Sub\`\${AWS.StackName}-logs\`,
   accessControl: "LogDeliveryWrite",
-  versioningConfiguration: _.versioningEnabled,
-  bucketEncryption: _.bucketEncryption,
-  publicAccessBlockConfiguration: _.publicAccessBlock,
+  versioningConfiguration: versioningEnabled,
+  bucketEncryption: bucketEncryption,
+  publicAccessBlockConfiguration: publicAccessBlock,
 });
 `,
     };
@@ -184,18 +184,9 @@ export const logsBucket = new aws.Bucket({
 
   async validate(options?: { verbose?: boolean }): Promise<void> {
     const { validate } = await import("./validate");
+    const { printValidationResult } = await import("@intentius/chant/codegen/validate");
     const result = await validate();
-
-    for (const check of result.checks) {
-      const status = check.ok ? "OK" : "FAIL";
-      const msg = check.error ? ` — ${check.error}` : "";
-      console.error(`  [${status}] ${check.name}${msg}`);
-    }
-
-    if (!result.success) {
-      throw new Error("Validation failed");
-    }
-    console.error("All validation checks passed.");
+    printValidationResult(result);
   },
 
   async coverage(options?: { verbose?: boolean; minOverall?: number }): Promise<void> {
@@ -226,34 +217,15 @@ export const logsBucket = new aws.Bucket({
 
   async package(options?: { verbose?: boolean; force?: boolean }): Promise<void> {
     const { packageLexicon } = await import("./codegen/package");
-    const { writeFileSync, mkdirSync } = await import("fs");
+    const { writeBundleSpec } = await import("@intentius/chant/codegen/package");
     const { join, dirname } = await import("path");
     const { fileURLToPath } = await import("url");
 
     const { spec, stats } = await packageLexicon({ verbose: options?.verbose, force: options?.force });
 
-    // Write manifest and artifacts to dist/
     const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
     const distDir = join(pkgDir, "dist");
-    mkdirSync(join(distDir, "types"), { recursive: true });
-    mkdirSync(join(distDir, "rules"), { recursive: true });
-    mkdirSync(join(distDir, "skills"), { recursive: true });
-
-    writeFileSync(join(distDir, "manifest.json"), JSON.stringify(spec.manifest, null, 2));
-    writeFileSync(join(distDir, "meta.json"), spec.registry);
-    writeFileSync(join(distDir, "types", "index.d.ts"), spec.typesDTS);
-
-    for (const [name, content] of spec.rules) {
-      writeFileSync(join(distDir, "rules", name), content);
-    }
-    for (const [name, content] of spec.skills) {
-      writeFileSync(join(distDir, "skills", name), content);
-    }
-
-    // Write integrity.json if available
-    if (spec.integrity) {
-      writeFileSync(join(distDir, "integrity.json"), JSON.stringify(spec.integrity, null, 2));
-    }
+    writeBundleSpec(spec, distDir);
 
     console.error(`Packaged ${stats.resources} resources, ${stats.ruleCount} rules, ${stats.skillCount} skills`);
 
@@ -348,7 +320,7 @@ description: AWS CloudFormation best practices and common patterns
 3. **Use least-privilege IAM** — Avoid \`*\` in IAM policy actions and resources
 4. **Enable versioning** — Turn on \`VersioningConfiguration\` for data buckets
 5. **Use Sub for dynamic names** — \`Sub\\\`\\\${AWS::StackName}-suffix\\\`\` for unique naming
-6. **Share config via barrel files** — Put common settings in \`_.ts\` and import as \`* as _\`
+6. **Share config via direct imports** — Put common settings in a config file and import directly
 `,
         triggers: [
           { type: "file-pattern", value: "**/*.aws.ts" },

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);

package/src/spec/parse.ts

@@ -36,7 +36,7 @@ export interface ParsedAttribute {
 
 export interface ParsedPropertyType {
   name: string;
-  cfnType: string;
+  specType: string;
   properties: ParsedProperty[];
 }
 
@@ -130,7 +130,7 @@ export function parseCFNSchema(data: string | Buffer): SchemaParseResult {
         }
         propertyTypes.push({
           name: `${shortName}_${defName}`,
-          cfnType: defName,
+          specType: defName,
           properties: defProps,
         });
       }