@intentius/chant-lexicon-aws 0.0.2

package/src/import/roundtrip.test.ts

@@ -0,0 +1,195 @@
+import { describe, test, expect } from "bun:test";
+import { CFParser } from "./parser";
+import { CFGenerator } from "./generator";
+
+describe("CloudFormation round-trip", () => {
+  const parser = new CFParser();
+  const generator = new CFGenerator();
+
+  test("round-trips simple S3 bucket", () => {
+    const original = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        MyBucket: {
+          Type: "AWS::S3::Bucket",
+          Properties: {
+            BucketName: "my-bucket",
+          },
+        },
+      },
+    };
+
+    const content = JSON.stringify(original);
+    const ir = parser.parse(content);
+    const files = generator.generate(ir);
+
+    expect(files[0].content).toContain("Bucket");
+    expect(files[0].content).toContain('bucketName: "my-bucket"');
+  });
+
+  test("round-trips template with parameters", () => {
+    const original = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Parameters: {
+        Environment: {
+          Type: "String",
+          Default: "dev",
+        },
+      },
+      Resources: {
+        MyBucket: {
+          Type: "AWS::S3::Bucket",
+          Properties: {
+            BucketName: { Ref: "Environment" },
+          },
+        },
+      },
+    };
+
+    const content = JSON.stringify(original);
+    const ir = parser.parse(content);
+    const files = generator.generate(ir);
+
+    expect(files[0].content).toContain("Parameter");
+    expect(files[0].content).toContain("environment");
+    expect(files[0].content).toContain("bucketName: environment");
+  });
+
+  test("round-trips template with Fn::Sub", () => {
+    const original = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        MyBucket: {
+          Type: "AWS::S3::Bucket",
+          Properties: {
+            BucketName: { "Fn::Sub": "${AWS::StackName}-data" },
+          },
+        },
+      },
+    };
+
+    const content = JSON.stringify(original);
+    const ir = parser.parse(content);
+    const files = generator.generate(ir);
+
+    expect(files[0].content).toContain("Sub");
+    expect(files[0].content).toContain("AWS.StackName");
+  });
+
+  test("round-trips Lambda with IAM Role", () => {
+    const original = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        LambdaRole: {
+          Type: "AWS::IAM::Role",
+          Properties: {
+            RoleName: "lambda-role",
+            AssumeRolePolicyDocument: {
+              Version: "2012-10-17",
+              Statement: [
+                {
+                  Effect: "Allow",
+                  Principal: { Service: "lambda.amazonaws.com" },
+                  Action: "sts:AssumeRole",
+                },
+              ],
+            },
+          },
+        },
+        MyFunction: {
+          Type: "AWS::Lambda::Function",
+          Properties: {
+            FunctionName: "my-function",
+            Runtime: "nodejs18.x",
+            Handler: "index.handler",
+            Role: { "Fn::GetAtt": ["LambdaRole", "Arn"] },
+          },
+        },
+      },
+    };
+
+    const content = JSON.stringify(original);
+    const ir = parser.parse(content);
+    const files = generator.generate(ir);
+
+    expect(files[0].content).toContain("Role");
+    expect(files[0].content).toContain("Function");
+    expect(files[0].content).toContain("lambdaRole.arn");
+  });
+
+  test("round-trips complex nested properties", () => {
+    const original = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        MyFunction: {
+          Type: "AWS::Lambda::Function",
+          Properties: {
+            FunctionName: "my-function",
+            Runtime: "nodejs18.x",
+            Handler: "index.handler",
+            Environment: {
+              Variables: {
+                NODE_ENV: "production",
+                LOG_LEVEL: "info",
+              },
+            },
+            VpcConfig: {
+              SecurityGroupIds: ["sg-12345"],
+              SubnetIds: ["subnet-abc", "subnet-def"],
+            },
+          },
+        },
+      },
+    };
+
+    const content = JSON.stringify(original);
+    const ir = parser.parse(content);
+    const files = generator.generate(ir);
+
+    expect(files[0].content).toContain("Function");
+    expect(files[0].content).toContain("environment");
+    expect(files[0].content).toContain("vpcConfig");
+  });
+
+  test("round-trips empty template", () => {
+    const original = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {},
+    };
+
+    const content = JSON.stringify(original);
+    const ir = parser.parse(content);
+    const files = generator.generate(ir);
+
+    expect(files).toHaveLength(1);
+    expect(files[0].path).toBe("main.ts");
+  });
+
+  test("handles multiple resource types", () => {
+    const original = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        MyBucket: {
+          Type: "AWS::S3::Bucket",
+          Properties: { BucketName: "bucket" },
+        },
+        MyQueue: {
+          Type: "AWS::SQS::Queue",
+          Properties: { QueueName: "queue" },
+        },
+        MyTopic: {
+          Type: "AWS::SNS::Topic",
+          Properties: { TopicName: "topic" },
+        },
+      },
+    };
+
+    const content = JSON.stringify(original);
+    const ir = parser.parse(content);
+    const files = generator.generate(ir);
+
+    expect(files[0].content).toContain("Bucket");
+    expect(files[0].content).toContain("Queue");
+    expect(files[0].content).toContain("Topic");
+  });
+});

package/src/index.ts

@@ -0,0 +1,63 @@
+// Serializer
+export { awsSerializer } from "./serializer";
+
+// Nested Stacks
+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
+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";
+
+// Plugin
+export { awsPlugin } from "./plugin";
+
+// Intrinsics
+export {
+  Sub,
+  Ref,
+  GetAtt,
+  If,
+  Join,
+  Select,
+  Split,
+  Base64,
+  SubIntrinsic,
+  RefIntrinsic,
+  GetAttIntrinsic,
+  IfIntrinsic,
+  JoinIntrinsic,
+  SelectIntrinsic,
+  SplitIntrinsic,
+  Base64Intrinsic,
+} from "./intrinsics";
+
+// Pseudo-parameters
+export {
+  AWS,
+  StackName,
+  Region,
+  AccountId,
+  StackId,
+  URLSuffix,
+  NoValue,
+  NotificationARNs,
+  Partition,
+} from "./pseudo";
+
+// Generated resources — export everything from generated index
+// After running `chant generate`, this re-exports all 1000+ resource classes
+export * from "./generated/index";
+
+// Spec utilities (for tooling)
+export { fetchSchemaZip } from "./spec/fetch";
+export type { CFNSchema, SchemaProperty, SchemaDefinition } from "./spec/fetch";
+export { parseCFNSchema, cfnShortName, cfnServiceName } from "./spec/parse";
+export type { SchemaParseResult, ParsedResource, ParsedProperty, ParsedAttribute, ParsedPropertyType, ParsedEnum, PropertyConstraints } from "./spec/parse";
+
+// Code generation pipeline
+export { generate, writeGeneratedFiles } from "./codegen/generate";
+export { packageLexicon } from "./codegen/package";
+export type { PackageOptions, PackageResult } from "./codegen/package";

package/src/integration.test.ts

@@ -0,0 +1,129 @@
+import { describe, test, expect } from "bun:test";
+import { awsSerializer } from "./serializer";
+import { Sub, If, Join, AWS } from "./index";
+import { Bucket, Function, Role } from "./generated/index";
+import { DECLARABLE_MARKER, type Declarable } from "@intentius/chant/declarable";
+
+describe("AWS Integration", () => {
+  describe("Serializer", () => {
+    test("produces valid CF JSON structure", () => {
+      const entities = new Map<string, Declarable>();
+      const output = awsSerializer.serialize(entities);
+      const template = JSON.parse(output);
+
+      expect(template.AWSTemplateFormatVersion).toBe("2010-09-09");
+      expect(template.Resources).toBeDefined();
+    });
+
+    test("serializes S3 bucket with properties", () => {
+      const bucket = new (Bucket as any)({
+        bucketName: "my-bucket",
+      });
+
+      const entities = new Map<string, Declarable>();
+      entities.set("MyBucket", bucket);
+
+      const output = awsSerializer.serialize(entities);
+      const template = JSON.parse(output);
+
+      expect(template.Resources.MyBucket.Type).toBe("AWS::S3::Bucket");
+      expect(template.Resources.MyBucket.Properties.BucketName).toBe("my-bucket");
+    });
+  });
+
+  describe("Intrinsics", () => {
+    test("Sub with pseudo-parameters", () => {
+      const result = Sub`${AWS.StackName}-bucket`;
+      expect(result.toJSON()).toEqual({ "Fn::Sub": "${AWS::StackName}-bucket" });
+    });
+
+    test("Sub with multiple interpolations", () => {
+      const result = Sub`${AWS.StackName}-${AWS.Region}-bucket`;
+      expect(result.toJSON()).toEqual({
+        "Fn::Sub": "${AWS::StackName}-${AWS::Region}-bucket",
+      });
+    });
+
+    test("If with string values", () => {
+      const result = If("IsProduction", "prod-bucket", "dev-bucket");
+      expect(result.toJSON()).toEqual({
+        "Fn::If": ["IsProduction", "prod-bucket", "dev-bucket"],
+      });
+    });
+
+    test("Join with array", () => {
+      const result = Join("-", ["my", "bucket", "name"]);
+      expect(result.toJSON()).toEqual({
+        "Fn::Join": ["-", ["my", "bucket", "name"]],
+      });
+    });
+  });
+
+  describe("Cross-resource references", () => {
+    test("GetAtt for bucket ARN", () => {
+      const bucket = new (Bucket as any)({ bucketName: "source" });
+      // Set logical name for the AttrRef
+      (bucket.arn as Record<string, unknown>)._setLogicalName("SourceBucket");
+
+      expect(bucket.arn.getLogicalName()).toBe("SourceBucket");
+      expect(bucket.arn.attribute).toBe("Arn");
+    });
+  });
+
+  describe("Resource types", () => {
+    test("Bucket has correct entity type", () => {
+      const bucket = new (Bucket as any)({});
+      expect(bucket.entityType).toBe("AWS::S3::Bucket");
+      expect(bucket[DECLARABLE_MARKER]).toBe(true);
+    });
+
+    test("Lambda Function has correct entity type", () => {
+      const fn = new (Function as any)({
+        runtime: "nodejs18.x",
+        handler: "index.handler",
+        code: { s3Bucket: "my-bucket", s3Key: "code.zip" },
+        role: "arn:aws:iam::123456789012:role/lambda-role",
+      });
+      expect(fn.entityType).toBe("AWS::Lambda::Function");
+      expect(fn[DECLARABLE_MARKER]).toBe(true);
+    });
+
+    test("IAM Role has correct entity type", () => {
+      const role = new (Role as any)({
+        assumeRolePolicyDocument: {
+          Version: "2012-10-17",
+          Statement: [],
+        },
+      });
+      expect(role.entityType).toBe("AWS::IAM::Role");
+      expect(role[DECLARABLE_MARKER]).toBe(true);
+    });
+  });
+
+  describe("AttrRefs", () => {
+    test("Bucket has expected AttrRefs", () => {
+      const bucket = new (Bucket as any)({});
+      expect(bucket.arn).toBeDefined();
+      expect(bucket.domainName).toBeDefined();
+      expect(bucket.websiteURL).toBeDefined();
+    });
+
+    test("Lambda Function has expected AttrRefs", () => {
+      const fn = new (Function as any)({
+        runtime: "nodejs18.x",
+        handler: "index.handler",
+        code: { s3Bucket: "bucket", s3Key: "key" },
+        role: "role-arn",
+      });
+      expect(fn.arn).toBeDefined();
+    });
+
+    test("IAM Role has expected AttrRefs", () => {
+      const role = new (Role as any)({
+        assumeRolePolicyDocument: {},
+      });
+      expect(role.arn).toBeDefined();
+      expect(role.roleId).toBeDefined();
+    });
+  });
+});

package/src/intrinsics.test.ts

@@ -0,0 +1,167 @@
+import { describe, test, expect } from "bun:test";
+import { Sub, Ref, GetAtt, If, Join, Select, Split, Base64 } from "./intrinsics";
+import { AWS } from "./pseudo";
+import { AttrRef } from "@intentius/chant/attrref";
+import { DECLARABLE_MARKER, type Declarable } from "@intentius/chant/declarable";
+
+// Mock declarable for testing
+class MockBucket implements Declarable {
+  readonly [DECLARABLE_MARKER] = true as const;
+  readonly lexicon = "aws";
+  readonly entityType = "AWS::S3::Bucket";
+  readonly arn: AttrRef;
+  readonly props = {};
+
+  constructor() {
+    this.arn = new AttrRef(this, "Arn");
+  }
+}
+
+describe("Sub intrinsic", () => {
+  test("creates simple template", () => {
+    const result = Sub`my-bucket`;
+    expect(result.toJSON()).toEqual({ "Fn::Sub": "my-bucket" });
+  });
+
+  test("interpolates string values", () => {
+    const env = "prod";
+    const result = Sub`my-bucket-${env}`;
+    expect(result.toJSON()).toEqual({ "Fn::Sub": "my-bucket-prod" });
+  });
+
+  test("interpolates pseudo-parameters", () => {
+    const result = Sub`${AWS.StackName}-bucket`;
+    expect(result.toJSON()).toEqual({ "Fn::Sub": "${AWS::StackName}-bucket" });
+  });
+
+  test("interpolates AttrRef", () => {
+    const bucket = new MockBucket();
+    // Set the logical name on the AttrRef
+    (bucket.arn as Record<string, unknown>)._setLogicalName("MyBucket");
+
+    const result = Sub`arn:aws:s3:::${bucket.arn}/*`;
+    expect(result.toJSON()["Fn::Sub"]).toContain("${MyBucket.Arn}");
+  });
+
+  test("handles multiple interpolations", () => {
+    const result = Sub`${AWS.StackName}-${AWS.Region}-bucket`;
+    expect(result.toJSON()).toEqual({
+      "Fn::Sub": "${AWS::StackName}-${AWS::Region}-bucket",
+    });
+  });
+
+  test("throws for direct Declarable when serializing", () => {
+    const bucket = new MockBucket();
+    const sub = Sub`${bucket as unknown}`;
+    expect(() => sub.toJSON()).toThrow("Cannot embed Declarable directly");
+  });
+});
+
+describe("Ref intrinsic", () => {
+  test("creates Ref for resource name", () => {
+    const result = Ref("MyBucket");
+    expect(result.toJSON()).toEqual({ Ref: "MyBucket" });
+  });
+
+  test("creates Ref for parameter", () => {
+    const result = Ref("Environment");
+    expect(result.toJSON()).toEqual({ Ref: "Environment" });
+  });
+});
+
+describe("GetAtt intrinsic", () => {
+  test("creates GetAtt", () => {
+    const result = GetAtt("MyBucket", "Arn");
+    expect(result.toJSON()).toEqual({ "Fn::GetAtt": ["MyBucket", "Arn"] });
+  });
+
+  test("handles dotted attribute names", () => {
+    const result = GetAtt("MyFunction", "SnapStartResponse.ApplyOn");
+    expect(result.toJSON()).toEqual({
+      "Fn::GetAtt": ["MyFunction", "SnapStartResponse.ApplyOn"],
+    });
+  });
+});
+
+describe("If intrinsic", () => {
+  test("creates If with values", () => {
+    const result = If("CreateProd", "prod-bucket", "dev-bucket");
+    expect(result.toJSON()).toEqual({
+      "Fn::If": ["CreateProd", "prod-bucket", "dev-bucket"],
+    });
+  });
+
+  test("handles nested intrinsics", () => {
+    const result = If("CreateProd", Ref("ProdBucket"), Ref("DevBucket"));
+    expect(result.toJSON()).toEqual({
+      "Fn::If": ["CreateProd", { Ref: "ProdBucket" }, { Ref: "DevBucket" }],
+    });
+  });
+});
+
+describe("Join intrinsic", () => {
+  test("joins strings", () => {
+    const result = Join("-", ["a", "b", "c"]);
+    expect(result.toJSON()).toEqual({ "Fn::Join": ["-", ["a", "b", "c"]] });
+  });
+
+  test("joins with empty delimiter", () => {
+    const result = Join("", ["hello", "world"]);
+    expect(result.toJSON()).toEqual({ "Fn::Join": ["", ["hello", "world"]] });
+  });
+
+  test("handles intrinsic values", () => {
+    const result = Join("-", [Ref("Prefix"), "bucket"]);
+    expect(result.toJSON()).toEqual({
+      "Fn::Join": ["-", [{ Ref: "Prefix" }, "bucket"]],
+    });
+  });
+});
+
+describe("Select intrinsic", () => {
+  test("selects from array", () => {
+    const result = Select(0, ["a", "b", "c"]);
+    expect(result.toJSON()).toEqual({ "Fn::Select": ["0", ["a", "b", "c"]] });
+  });
+
+  test("selects with intrinsic array", () => {
+    const result = Select(1, [Ref("A"), Ref("B")]);
+    expect(result.toJSON()).toEqual({
+      "Fn::Select": ["1", [{ Ref: "A" }, { Ref: "B" }]],
+    });
+  });
+});
+
+describe("Split intrinsic", () => {
+  test("splits string", () => {
+    const result = Split(",", "a,b,c");
+    expect(result.toJSON()).toEqual({ "Fn::Split": [",", "a,b,c"] });
+  });
+
+  test("splits with intrinsic source", () => {
+    const result = Split(",", Ref("CommaSeparatedList"));
+    expect(result.toJSON()).toEqual({
+      "Fn::Split": [",", { Ref: "CommaSeparatedList" }],
+    });
+  });
+});
+
+describe("Base64 intrinsic", () => {
+  test("encodes string", () => {
+    const result = Base64("Hello World");
+    expect(result.toJSON()).toEqual({ "Fn::Base64": "Hello World" });
+  });
+
+  test("encodes intrinsic result", () => {
+    const result = Base64(Ref("UserData"));
+    expect(result.toJSON()).toEqual({ "Fn::Base64": { Ref: "UserData" } });
+  });
+
+  test("handles nested Sub", () => {
+    const result = Base64(Sub`#!/bin/bash\necho ${AWS.StackName}`);
+    const json = result.toJSON();
+    expect(json["Fn::Base64"]).toEqual({
+      "Fn::Sub": "#!/bin/bash\necho ${AWS::StackName}",
+    });
+  });
+});