@intentius/chant-lexicon-aws 0.0.2

package/src/import/parser.test.ts

@@ -0,0 +1,200 @@
+import { describe, test, expect } from "bun:test";
+import { CFParser } from "./parser";
+
+describe("CFParser", () => {
+  const parser = new CFParser();
+
+  test("parses empty template", () => {
+    const content = JSON.stringify({
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {},
+    });
+
+    const ir = parser.parse(content);
+
+    expect(ir.parameters).toHaveLength(0);
+    expect(ir.resources).toHaveLength(0);
+    expect(ir.metadata?.version).toBe("2010-09-09");
+  });
+
+  test("parses parameters", () => {
+    const content = JSON.stringify({
+      AWSTemplateFormatVersion: "2010-09-09",
+      Parameters: {
+        Environment: {
+          Type: "String",
+          Description: "Environment name",
+          Default: "dev",
+        },
+      },
+      Resources: {},
+    });
+
+    const ir = parser.parse(content);
+
+    expect(ir.parameters).toHaveLength(1);
+    expect(ir.parameters[0].name).toBe("Environment");
+    expect(ir.parameters[0].type).toBe("String");
+    expect(ir.parameters[0].description).toBe("Environment name");
+    expect(ir.parameters[0].defaultValue).toBe("dev");
+  });
+
+  test("parses S3 bucket resource", () => {
+    const content = JSON.stringify({
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        MyBucket: {
+          Type: "AWS::S3::Bucket",
+          Properties: {
+            BucketName: "my-bucket",
+            VersioningConfiguration: {
+              Status: "Enabled",
+            },
+          },
+        },
+      },
+    });
+
+    const ir = parser.parse(content);
+
+    expect(ir.resources).toHaveLength(1);
+    expect(ir.resources[0].logicalId).toBe("MyBucket");
+    expect(ir.resources[0].type).toBe("AWS::S3::Bucket");
+    expect(ir.resources[0].properties.BucketName).toBe("my-bucket");
+  });
+
+  test("parses Ref intrinsic", () => {
+    const content = JSON.stringify({
+      AWSTemplateFormatVersion: "2010-09-09",
+      Parameters: {
+        BucketName: { Type: "String" },
+      },
+      Resources: {
+        MyBucket: {
+          Type: "AWS::S3::Bucket",
+          Properties: {
+            BucketName: { Ref: "BucketName" },
+          },
+        },
+      },
+    });
+
+    const ir = parser.parse(content);
+
+    const nameProp = ir.resources[0].properties.BucketName as Record<string, unknown>;
+    expect(nameProp.__intrinsic).toBe("Ref");
+    expect(nameProp.name).toBe("BucketName");
+  });
+
+  test("parses Fn::GetAtt array form", () => {
+    const content = JSON.stringify({
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        Source: { Type: "AWS::S3::Bucket", Properties: {} },
+        Dest: {
+          Type: "AWS::S3::Bucket",
+          Properties: {
+            SourceArn: { "Fn::GetAtt": ["Source", "Arn"] },
+          },
+        },
+      },
+    });
+
+    const ir = parser.parse(content);
+
+    const dest = ir.resources.find((r) => r.logicalId === "Dest");
+    const prop = dest?.properties.SourceArn as Record<string, unknown>;
+    expect(prop.__intrinsic).toBe("GetAtt");
+    expect(prop.logicalId).toBe("Source");
+    expect(prop.attribute).toBe("Arn");
+  });
+
+  test("parses Fn::Sub string form", () => {
+    const content = JSON.stringify({
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        MyBucket: {
+          Type: "AWS::S3::Bucket",
+          Properties: {
+            BucketName: { "Fn::Sub": "${AWS::StackName}-bucket" },
+          },
+        },
+      },
+    });
+
+    const ir = parser.parse(content);
+
+    const prop = ir.resources[0].properties.BucketName as Record<string, unknown>;
+    expect(prop.__intrinsic).toBe("Sub");
+    expect(prop.template).toBe("${AWS::StackName}-bucket");
+  });
+
+  test("parses Fn::If", () => {
+    const content = JSON.stringify({
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        MyBucket: {
+          Type: "AWS::S3::Bucket",
+          Properties: {
+            BucketName: {
+              "Fn::If": ["CreateProd", "prod-bucket", "dev-bucket"],
+            },
+          },
+        },
+      },
+    });
+
+    const ir = parser.parse(content);
+
+    const prop = ir.resources[0].properties.BucketName as Record<string, unknown>;
+    expect(prop.__intrinsic).toBe("If");
+    expect(prop.condition).toBe("CreateProd");
+    expect(prop.valueIfTrue).toBe("prod-bucket");
+    expect(prop.valueIfFalse).toBe("dev-bucket");
+  });
+
+  test("parses Fn::Join", () => {
+    const content = JSON.stringify({
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        MyBucket: {
+          Type: "AWS::S3::Bucket",
+          Properties: {
+            BucketName: { "Fn::Join": ["-", ["my", "bucket"]] },
+          },
+        },
+      },
+    });
+
+    const ir = parser.parse(content);
+
+    const prop = ir.resources[0].properties.BucketName as Record<string, unknown>;
+    expect(prop.__intrinsic).toBe("Join");
+    expect(prop.delimiter).toBe("-");
+    expect(prop.values).toEqual(["my", "bucket"]);
+  });
+
+  test("parses nested properties", () => {
+    const content = JSON.stringify({
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        MyFunction: {
+          Type: "AWS::Lambda::Function",
+          Properties: {
+            Environment: {
+              Variables: {
+                KEY: "value",
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const ir = parser.parse(content);
+
+    const env = ir.resources[0].properties.Environment as Record<string, unknown>;
+    const vars = env.Variables as Record<string, unknown>;
+    expect(vars.KEY).toBe("value");
+  });
+});

package/src/import/parser.ts

@@ -0,0 +1,350 @@
+import type {
+  TemplateParser,
+  TemplateIR,
+  ResourceIR,
+  ParameterIR,
+} from "@intentius/chant/import/parser";
+import { BaseValueParser } from "@intentius/chant/import/base-parser";
+import yaml from "js-yaml";
+
+/**
+ * Custom YAML schema for CloudFormation shorthand tags (!Ref, !Sub, !GetAtt, etc.)
+ */
+const cfnYamlTypes = [
+  new yaml.Type("!Ref", {
+    kind: "scalar",
+    construct: (data: string) => ({ Ref: data }),
+  }),
+  new yaml.Type("!Sub", {
+    kind: "scalar",
+    construct: (data: string) => ({ "Fn::Sub": data }),
+  }),
+  new yaml.Type("!Sub", {
+    kind: "sequence",
+    construct: (data: unknown[]) => ({ "Fn::Sub": data }),
+  }),
+  new yaml.Type("!GetAtt", {
+    kind: "scalar",
+    construct: (data: string) => ({ "Fn::GetAtt": data.split(".") }),
+  }),
+  new yaml.Type("!GetAtt", {
+    kind: "sequence",
+    construct: (data: unknown[]) => ({ "Fn::GetAtt": data }),
+  }),
+  new yaml.Type("!Join", {
+    kind: "sequence",
+    construct: (data: unknown[]) => ({ "Fn::Join": data }),
+  }),
+  new yaml.Type("!Select", {
+    kind: "sequence",
+    construct: (data: unknown[]) => ({ "Fn::Select": data }),
+  }),
+  new yaml.Type("!Split", {
+    kind: "sequence",
+    construct: (data: unknown[]) => ({ "Fn::Split": data }),
+  }),
+  new yaml.Type("!If", {
+    kind: "sequence",
+    construct: (data: unknown[]) => ({ "Fn::If": data }),
+  }),
+  new yaml.Type("!Equals", {
+    kind: "sequence",
+    construct: (data: unknown[]) => ({ "Fn::Equals": data }),
+  }),
+  new yaml.Type("!Not", {
+    kind: "sequence",
+    construct: (data: unknown[]) => ({ "Fn::Not": data }),
+  }),
+  new yaml.Type("!And", {
+    kind: "sequence",
+    construct: (data: unknown[]) => ({ "Fn::And": data }),
+  }),
+  new yaml.Type("!Or", {
+    kind: "sequence",
+    construct: (data: unknown[]) => ({ "Fn::Or": data }),
+  }),
+  new yaml.Type("!FindInMap", {
+    kind: "sequence",
+    construct: (data: unknown[]) => ({ "Fn::FindInMap": data }),
+  }),
+  new yaml.Type("!Base64", {
+    kind: "scalar",
+    construct: (data: string) => ({ "Fn::Base64": data }),
+  }),
+  new yaml.Type("!Base64", {
+    kind: "mapping",
+    construct: (data: unknown) => ({ "Fn::Base64": data }),
+  }),
+  new yaml.Type("!Cidr", {
+    kind: "sequence",
+    construct: (data: unknown[]) => ({ "Fn::Cidr": data }),
+  }),
+  new yaml.Type("!ImportValue", {
+    kind: "scalar",
+    construct: (data: string) => ({ "Fn::ImportValue": data }),
+  }),
+  new yaml.Type("!ImportValue", {
+    kind: "mapping",
+    construct: (data: unknown) => ({ "Fn::ImportValue": data }),
+  }),
+  new yaml.Type("!GetAZs", {
+    kind: "scalar",
+    construct: (data: string) => ({ "Fn::GetAZs": data }),
+  }),
+  new yaml.Type("!GetAZs", {
+    kind: "mapping",
+    construct: (data: unknown) => ({ "Fn::GetAZs": data }),
+  }),
+  new yaml.Type("!Transform", {
+    kind: "mapping",
+    construct: (data: unknown) => ({ "Fn::Transform": data }),
+  }),
+  new yaml.Type("!Condition", {
+    kind: "scalar",
+    construct: (data: string) => ({ Condition: data }),
+  }),
+];
+
+const CF_SCHEMA = yaml.DEFAULT_SCHEMA.extend(cfnYamlTypes);
+
+/**
+ * CloudFormation template structure
+ */
+interface CFTemplate {
+  AWSTemplateFormatVersion?: string;
+  Description?: string;
+  Parameters?: Record<string, CFParameter>;
+  Resources?: Record<string, CFResource>;
+  Outputs?: Record<string, unknown>;
+}
+
+/**
+ * CloudFormation parameter
+ */
+interface CFParameter {
+  Type: string;
+  Description?: string;
+  Default?: unknown;
+}
+
+/**
+ * CloudFormation resource
+ */
+interface CFResource {
+  Type: string;
+  Properties?: Record<string, unknown>;
+  Metadata?: Record<string, unknown>;
+  DependsOn?: string | string[];
+}
+
+/**
+ * Parser for CloudFormation JSON templates.
+ * Extends BaseValueParser for generic recursive value walking;
+ * overrides dispatchIntrinsic with the CFN-specific dispatch table.
+ */
+export class CFParser extends BaseValueParser implements TemplateParser {
+  /**
+   * Parse CF JSON content into intermediate representation
+   */
+  parse(content: string): TemplateIR {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      parsed = yaml.load(content, { schema: CF_SCHEMA });
+    }
+    const template = parsed as CFTemplate;
+
+    const parameters = this.parseParameters(template.Parameters ?? {});
+    const resources = this.parseResources(template.Resources ?? {});
+
+    return {
+      parameters,
+      resources,
+      metadata: {
+        version: template.AWSTemplateFormatVersion ?? "2010-09-09",
+        description: template.Description,
+      },
+    };
+  }
+
+  /**
+   * Parse parameters section
+   */
+  private parseParameters(params: Record<string, CFParameter>): ParameterIR[] {
+    return Object.entries(params).map(([name, param]) => ({
+      name,
+      type: param.Type,
+      description: param.Description,
+      defaultValue: param.Default,
+      required: param.Default === undefined,
+    }));
+  }
+
+  /**
+   * Parse resources section
+   */
+  private parseResources(resources: Record<string, CFResource>): ResourceIR[] {
+    return Object.entries(resources)
+      .filter(([_, resource]) => typeof resource?.Type === "string")
+      .map(([logicalId, resource]) => ({
+        logicalId,
+        type: resource.Type,
+        properties: this.parseProperties(resource.Properties ?? {}),
+        metadata: resource.Metadata,
+      }));
+  }
+
+  /**
+   * Parse resource properties, handling intrinsic functions
+   */
+  private parseProperties(props: Record<string, unknown>): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+
+    for (const [key, value] of Object.entries(props)) {
+      result[key] = this.parseValue(value);
+    }
+
+    return result;
+  }
+
+  /**
+   * CFN-specific intrinsic dispatch table.
+   */
+  protected dispatchIntrinsic(key: string, value: unknown, _obj: Record<string, unknown>): unknown | null {
+    if (key === "Ref") {
+      return { __intrinsic: "Ref", name: value };
+    }
+
+    if (key === "Fn::GetAtt") {
+      if (Array.isArray(value) && value.length === 2) {
+        return { __intrinsic: "GetAtt", logicalId: value[0], attribute: value[1] };
+      }
+      if (typeof value === "string") {
+        const [logicalId, attribute] = value.split(".");
+        return { __intrinsic: "GetAtt", logicalId, attribute };
+      }
+    }
+
+    if (key === "Fn::Sub") {
+      if (typeof value === "string") {
+        return { __intrinsic: "Sub", template: value };
+      }
+      if (Array.isArray(value) && value.length >= 1) {
+        return { __intrinsic: "Sub", template: value[0], variables: value[1] };
+      }
+    }
+
+    if (key === "Fn::If") {
+      const ifValue = value as unknown[];
+      return {
+        __intrinsic: "If",
+        condition: ifValue[0],
+        valueIfTrue: this.parseValue(ifValue[1]),
+        valueIfFalse: this.parseValue(ifValue[2]),
+      };
+    }
+
+    if (key === "Fn::Join") {
+      const joinValue = value as [string, unknown];
+      const delimiter = joinValue[0];
+      const source = joinValue[1];
+      return {
+        __intrinsic: "Join",
+        delimiter,
+        values: Array.isArray(source)
+          ? source.map((v) => this.parseValue(v))
+          : [this.parseValue(source)],
+      };
+    }
+
+    if (key === "Fn::Select") {
+      const selectValue = value as [string | number, unknown];
+      const index = Number(selectValue[0]);
+      const source = selectValue[1];
+      if (Array.isArray(source)) {
+        return {
+          __intrinsic: "Select",
+          index,
+          values: source.map((v) => this.parseValue(v)),
+        };
+      }
+      return {
+        __intrinsic: "Select",
+        index,
+        values: [this.parseValue(source)],
+      };
+    }
+
+    if (key === "Fn::Split") {
+      const splitValue = value as [string, unknown];
+      return {
+        __intrinsic: "Split",
+        delimiter: splitValue[0],
+        source: this.parseValue(splitValue[1]),
+      };
+    }
+
+    if (key === "Fn::Base64") {
+      return { __intrinsic: "Base64", value: this.parseValue(value) };
+    }
+
+    if (key === "Fn::FindInMap") {
+      const mapValue = value as unknown[];
+      return {
+        __intrinsic: "FindInMap",
+        mapName: mapValue[0],
+        firstKey: this.parseValue(mapValue[1]),
+        secondKey: this.parseValue(mapValue[2]),
+      };
+    }
+
+    if (key === "Fn::GetAZs") {
+      return { __intrinsic: "GetAZs", region: this.parseValue(value) };
+    }
+
+    if (key === "Fn::ImportValue") {
+      return { __intrinsic: "ImportValue", value: this.parseValue(value) };
+    }
+
+    if (key === "Fn::Cidr") {
+      const cidrValue = value as unknown[];
+      return {
+        __intrinsic: "Cidr",
+        ipBlock: this.parseValue(cidrValue[0]),
+        count: this.parseValue(cidrValue[1]),
+        cidrBits: this.parseValue(cidrValue[2]),
+      };
+    }
+
+    if (key === "Fn::Transform") {
+      return { __intrinsic: "Transform", value };
+    }
+
+    if (key === "Fn::Equals") {
+      const eqValue = value as unknown[];
+      return {
+        __intrinsic: "Equals",
+        left: this.parseValue(eqValue[0]),
+        right: this.parseValue(eqValue[1]),
+      };
+    }
+
+    if (key === "Fn::Not") {
+      const notValue = value as unknown[];
+      return { __intrinsic: "Not", condition: this.parseValue(notValue[0]) };
+    }
+
+    if (key === "Fn::And") {
+      const andValue = value as unknown[];
+      return { __intrinsic: "And", conditions: andValue.map((v) => this.parseValue(v)) };
+    }
+
+    if (key === "Fn::Or") {
+      const orValue = value as unknown[];
+      return { __intrinsic: "Or", conditions: orValue.map((v) => this.parseValue(v)) };
+    }
+
+    return null;
+  }
+}

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

@@ -0,0 +1,78 @@
+import { describe, test, expect } from "bun:test";
+import { readdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { CFParser } from "./parser";
+import { CFGenerator } from "./generator";
+
+const parser = new CFParser();
+const generator = new CFGenerator();
+
+const roundtripDir = join(import.meta.dir, "../testdata/roundtrip");
+const samDir = join(import.meta.dir, "../testdata/sam-fixtures");
+
+describe("CF roundtrip fixtures", () => {
+  const fixtures = readdirSync(roundtripDir).filter((f) => f.endsWith(".json"));
+
+  for (const fixture of fixtures) {
+    test(`roundtrip: ${fixture}`, () => {
+      const content = readFileSync(join(roundtripDir, fixture), "utf-8");
+      const template = JSON.parse(content);
+
+      const ir = parser.parse(content);
+      const files = generator.generate(ir);
+
+      // 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 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");
+      expect(mainFile).toBeDefined();
+
+      for (const name of resourceNames) {
+        const varName = name.charAt(0).toLowerCase() + name.slice(1);
+        expect(mainFile!.content).toContain(varName);
+      }
+
+      // 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);
+      }
+    });
+  }
+});
+
+describe("SAM roundtrip fixtures", () => {
+  const fixtures = readdirSync(samDir).filter(
+    (f) => f.endsWith(".yaml") || f.endsWith(".yml"),
+  );
+
+  for (const fixture of fixtures) {
+    test(`SAM roundtrip: ${fixture}`, () => {
+      const content = readFileSync(join(samDir, fixture), "utf-8");
+
+      // Parse should not throw (YAML support)
+      const ir = parser.parse(content);
+
+      // Generate should produce output
+      const files = generator.generate(ir);
+
+      // Verify at least one .ts file was generated
+      expect(files.length).toBeGreaterThanOrEqual(1);
+      expect(files.some((f) => f.path.endsWith(".ts"))).toBe(true);
+
+      // Verify no empty content
+      for (const file of files) {
+        expect(file.content.length).toBeGreaterThan(0);
+      }
+    });
+  }
+});