@intentius/chant-lexicon-aws 0.108.1 → 0.110.0

package/src/import/parser.ts

@@ -27,7 +27,12 @@ const cfnYamlTypes = [
   }),
   new yaml.Type("!GetAtt", {
     kind: "scalar",
-    construct: (data: string) => ({ "Fn::GetAtt": data.split(".") }),
+    // `!GetAtt Db.Endpoint.Address` names the attribute `Endpoint.Address`:
+    // the logical id ends at the first dot.
+    construct: (data: string) => {
+      const dot = data.indexOf(".");
+      return { "Fn::GetAtt": dot < 0 ? [data] : [data.slice(0, dot), data.slice(dot + 1)] };
+    },
   }),
   new yaml.Type("!GetAtt", {
     kind: "sequence",
@@ -115,6 +120,8 @@ const CF_SCHEMA = yaml.DEFAULT_SCHEMA.extend(cfnYamlTypes);
 interface CFTemplate {
   AWSTemplateFormatVersion?: string;
   Description?: string;
+  Metadata?: Record<string, unknown>;
+  Mappings?: Record<string, Record<string, Record<string, unknown>>>;
   Parameters?: Record<string, CFParameter>;
   Conditions?: Record<string, unknown>;
   Resources?: Record<string, CFResource>;
@@ -138,8 +145,24 @@ interface CFParameter {
   Type: string;
   Description?: string;
   Default?: unknown;
+  [constraint: string]: unknown;
 }
 
+/** Parameter keys import carries besides Type, Description and Default. */
+const PARAMETER_CONSTRAINT_KEYS = [
+  "AllowedValues",
+  "AllowedPattern",
+  "ConstraintDescription",
+  "MinLength",
+  "MaxLength",
+  "MinValue",
+  "MaxValue",
+  "NoEcho",
+] as const;
+
+/** Resource attributes import carries besides Type, Properties, Metadata and Condition. */
+const RESOURCE_ATTRIBUTE_KEYS = ["DependsOn", "DeletionPolicy", "UpdateReplacePolicy", "UpdatePolicy", "CreationPolicy"] as const;
+
 /**
  * CloudFormation resource
  */
@@ -149,6 +172,10 @@ interface CFResource {
   Metadata?: Record<string, unknown>;
   DependsOn?: string | string[];
   Condition?: string;
+  DeletionPolicy?: string;
+  UpdateReplacePolicy?: string;
+  UpdatePolicy?: unknown;
+  CreationPolicy?: unknown;
 }
 
 /**
@@ -184,6 +211,8 @@ export class CFParser extends BaseValueParser implements TemplateParser {
       metadata: {
         version: template.AWSTemplateFormatVersion ?? "2010-09-09",
         description: template.Description,
+        ...(template.Metadata !== undefined ? { templateMetadata: this.parseValue(template.Metadata) } : {}),
+        ...(template.Mappings !== undefined ? { mappings: template.Mappings } : {}),
       },
     };
   }
@@ -195,6 +224,8 @@ export class CFParser extends BaseValueParser implements TemplateParser {
   private static readonly CARRIED_SECTIONS = new Set([
     "AWSTemplateFormatVersion",
     "Description",
+    "Metadata",
+    "Mappings",
     "Parameters",
     "Conditions",
     "Resources",
@@ -250,13 +281,19 @@ export class CFParser extends BaseValueParser implements TemplateParser {
    * 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,
-    }));
+    return Object.entries(params).map(([name, param]) => {
+      const constraints = Object.fromEntries(
+        PARAMETER_CONSTRAINT_KEYS.filter((k) => param[k] !== undefined).map((k) => [k, param[k]]),
+      );
+      return {
+        name,
+        type: param.Type,
+        description: param.Description,
+        defaultValue: param.Default,
+        required: param.Default === undefined,
+        ...(Object.keys(constraints).length > 0 ? { constraints } : {}),
+      };
+    });
   }
 
   /**
@@ -265,13 +302,19 @@ export class CFParser extends BaseValueParser implements TemplateParser {
   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,
-        condition: typeof resource.Condition === "string" ? resource.Condition : undefined,
-      }));
+      .map(([logicalId, resource]) => {
+        const attributes = Object.fromEntries(
+          RESOURCE_ATTRIBUTE_KEYS.filter((k) => resource[k] !== undefined).map((k) => [k, this.parseValue(resource[k])]),
+        );
+        return {
+          logicalId,
+          type: resource.Type,
+          properties: this.parseProperties(resource.Properties ?? {}),
+          metadata: resource.Metadata !== undefined ? (this.parseValue(resource.Metadata) as Record<string, unknown>) : undefined,
+          condition: typeof resource.Condition === "string" ? resource.Condition : undefined,
+          ...(Object.keys(attributes).length > 0 ? { attributes } : {}),
+        };
+      });
   }
 
   /**
@@ -305,9 +348,9 @@ export class CFParser extends BaseValueParser implements TemplateParser {
       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(".", 2);
-        return { __intrinsic: "GetAtt", logicalId, attribute };
+      if (typeof value === "string" && value.indexOf(".") > 0) {
+        const dot = value.indexOf(".");
+        return { __intrinsic: "GetAtt", logicalId: value.slice(0, dot), attribute: value.slice(dot + 1) };
       }
     }
 
@@ -344,8 +387,12 @@ export class CFParser extends BaseValueParser implements TemplateParser {
     }
 
     if (key === "Fn::Select") {
+      // The index is kept as written (0 or "0"). A list source is `values`;
+      // anything else (a Ref to a list parameter, Fn::GetAZs, Fn::Split) is
+      // `source`, the list itself. Wrapping it in a list would select the
+      // list rather than an item of it.
       const selectValue = value as [string | number, unknown];
-      const index = Number(selectValue[0]);
+      const index = selectValue[0];
       const source = selectValue[1];
       if (Array.isArray(source)) {
         return {
@@ -357,7 +404,7 @@ export class CFParser extends BaseValueParser implements TemplateParser {
       return {
         __intrinsic: "Select",
         index,
-        values: [this.parseValue(source)],
+        source: this.parseValue(source),
       };
     }
 
@@ -376,9 +423,15 @@ export class CFParser extends BaseValueParser implements TemplateParser {
 
     if (key === "Fn::FindInMap") {
       const mapValue = value as unknown[];
+      if (!Array.isArray(mapValue) || mapValue.length !== 3) {
+        throw new Error(
+          `Fn::FindInMap takes [MapName, TopLevelKey, SecondLevelKey]; this one has ${JSON.stringify(value)} ` +
+            "(a fourth DefaultValue argument needs AWS::LanguageExtensions, which import does not carry)",
+        );
+      }
       return {
         __intrinsic: "FindInMap",
-        mapName: mapValue[0],
+        mapName: this.parseValue(mapValue[0]),
         firstKey: this.parseValue(mapValue[1]),
         secondKey: this.parseValue(mapValue[2]),
       };

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

@@ -0,0 +1,322 @@
+/**
+ * Import, then build the generated source, then compare with the template
+ * imported. Each case is a shape from a real template that did not come back.
+ */
+import { describe, test, expect } from "vitest";
+import { 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 { generateOrganizedFiles } from "@intentius/chant/cli/commands/import";
+import { awsSerializer } from "../serializer";
+
+const parser = new CFParser();
+const generator = new CFGenerator();
+
+/** Import `content` with the layout `chant import` uses, build what it wrote, and return the built template. */
+async function roundTrip(content: string): Promise<{ template: Record<string, any>; source: string }> {
+  const { files } = generateOrganizedFiles(parser.parse(content), generator);
+  expect(files.map((f) => f.path)).toEqual(["main.ts"]);
+  const source = files[0].content;
+  const dir = mkdtempSync(join(import.meta.dirname, "../../.roundtrip-tmp-"));
+  try {
+    const srcDir = join(dir, "src");
+    mkdirSync(srcDir);
+    writeFileSync(join(srcDir, "main.ts"), source);
+    const result = await build(srcDir, [awsSerializer]);
+    expect(result.errors.map((e) => e.message)).toEqual([]);
+    return { template: JSON.parse(result.outputs.get("aws") as string), source };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+describe("import layout", () => {
+  test("the generator writes the whole template to one main.ts", () => {
+    expect(generator.ownsLayout).toBe(true);
+  });
+
+  test("a template of more than three resources across categories builds from one file", async () => {
+    const original = {
+      Parameters: { AppName: { Type: "String" } },
+      Resources: {
+        MyCluster: { Type: "AWS::ECS::Cluster", Properties: { ClusterName: { Ref: "AppName" } } },
+        MyBucket: { Type: "AWS::S3::Bucket", Properties: { BucketName: { Ref: "AppName" } } },
+        MyQueue: { Type: "AWS::SQS::Queue", Properties: { QueueName: { Ref: "AppName" } } },
+        MyTopic: { Type: "AWS::SNS::Topic", Properties: { TopicName: { "Fn::GetAtt": ["MyQueue", "Arn"] } } },
+      },
+    };
+    const { template } = await roundTrip(JSON.stringify(original));
+    expect(template.Resources).toEqual(original.Resources);
+  });
+});
+
+describe("Fn::Sub", () => {
+  test("a bare ${Name} of a parameter or resource, and a ${!Literal}, come back as written", async () => {
+    const sub = "${Env}-${MyBucket}-${MyBucket.Arn}-${AWS::Region}-${!Literal}";
+    const original = {
+      Parameters: { Env: { Type: "String" } },
+      Resources: {
+        MyBucket: { Type: "AWS::S3::Bucket" },
+        MyQueue: { Type: "AWS::SQS::Queue", Properties: { QueueName: { "Fn::Sub": sub } } },
+      },
+    };
+    const { template, source } = await roundTrip(JSON.stringify(original));
+    expect(source).toContain("${Ref(Env)}-${Ref(MyBucket)}-${MyBucket.Arn}");
+    expect(template.Resources.MyQueue.Properties.QueueName).toEqual({ "Fn::Sub": sub });
+  });
+
+  test("a dotted name the class does not expose stays a ${Id.Attr} reference", async () => {
+    const sub = "queue ${MyQueue.QueueName}";
+    const original = {
+      Resources: {
+        MyQueue: { Type: "AWS::SQS::Queue" },
+        MyTopic: { Type: "AWS::SNS::Topic", Properties: { DisplayName: { "Fn::Sub": sub } } },
+      },
+    };
+    const { template } = await roundTrip(JSON.stringify(original));
+    expect(template.Resources.MyTopic.Properties.DisplayName).toEqual({ "Fn::Sub": sub });
+  });
+});
+
+describe("Fn::GetAtt", () => {
+  test("an attribute the class does not list is written by name, and the output keeps it", async () => {
+    const original = {
+      Resources: {
+        MyQueue: { Type: "AWS::SQS::Queue" },
+        MyTopic: { Type: "AWS::SNS::Topic", Properties: { DisplayName: { "Fn::GetAtt": ["MyQueue", "QueueName"] } } },
+      },
+      Outputs: {
+        Name: { Value: { "Fn::GetAtt": ["MyQueue", "QueueName"] } },
+        Arn: { Value: { "Fn::GetAtt": ["MyQueue", "Arn"] } },
+      },
+    };
+    const { template, source } = await roundTrip(JSON.stringify(original));
+    expect(source).toContain('GetAtt("MyQueue", "QueueName")');
+    expect(template.Resources.MyTopic.Properties).toEqual(original.Resources.MyTopic.Properties);
+    expect(template.Outputs).toEqual(original.Outputs);
+  });
+
+  test("YAML !GetAtt Db.Endpoint.Address names the attribute Endpoint.Address", async () => {
+    const yaml = [
+      "Resources:",
+      "  MyDB:",
+      "    Type: AWS::RDS::DBInstance",
+      "    Properties:",
+      "      DBInstanceClass: db.t3.micro",
+      "      Engine: mysql",
+      "      StorageEncrypted: true",
+      "      BackupRetentionPeriod: 7",
+      "Outputs:",
+      "  Address:",
+      "    Value: !Join ['', ['jdbc:mysql://', !GetAtt MyDB.Endpoint.Address, ':', !GetAtt MyDB.Endpoint.Port]]",
+    ].join("\n");
+    const ir = parser.parse(yaml);
+    expect(ir.outputs?.[0].value).toMatchObject({
+      values: [
+        "jdbc:mysql://",
+        { __intrinsic: "GetAtt", logicalId: "MyDB", attribute: "Endpoint.Address" },
+        ":",
+        { __intrinsic: "GetAtt", logicalId: "MyDB", attribute: "Endpoint.Port" },
+      ],
+    });
+    const { template } = await roundTrip(yaml);
+    expect(template.Outputs.Address.Value).toEqual({
+      "Fn::Join": [
+        "",
+        ["jdbc:mysql://", { "Fn::GetAtt": ["MyDB", "Endpoint.Address"] }, ":", { "Fn::GetAtt": ["MyDB", "Endpoint.Port"] }],
+      ],
+    });
+  });
+});
+
+describe("what import used to drop", () => {
+  test("resource attributes come back: DependsOn, the policies, and Metadata with an intrinsic in it", async () => {
+    const original = {
+      Resources: {
+        MyQueue: {
+          Type: "AWS::SQS::Queue",
+          DeletionPolicy: "Retain",
+          UpdateReplacePolicy: "Retain",
+          Metadata: { Note: { "Fn::Sub": "${AWS::StackName}-queue" } },
+        },
+        MyDB: {
+          Type: "AWS::RDS::DBInstance",
+          DependsOn: ["MyQueue", "MyGroup"],
+          DeletionPolicy: "Snapshot",
+          UpdateReplacePolicy: "Snapshot",
+          Properties: { DBInstanceClass: "db.t3.micro", Engine: "mysql", StorageEncrypted: true, BackupRetentionPeriod: 7 },
+        },
+        MyGroup: {
+          Type: "AWS::AutoScaling::AutoScalingGroup",
+          DependsOn: "MyQueue",
+          CreationPolicy: { ResourceSignal: { Count: 1, Timeout: "PT15M" } },
+          UpdatePolicy: { AutoScalingRollingUpdate: { MinInstancesInService: 1 } },
+          Properties: { MinSize: "1", MaxSize: "2", AvailabilityZones: ["us-east-1a"] },
+        },
+      },
+    };
+    const { template, source } = await roundTrip(JSON.stringify(original));
+    expect(source).toContain("DependsOn: [MyQueue, MyGroup]");
+    expect(template.Resources).toEqual(original.Resources);
+  });
+
+  test("the template's Description and Metadata come back", async () => {
+    const original = {
+      Description: "A queue",
+      Metadata: { "cfn-lint": { config: { ignore_checks: ["W3005"] } }, Stack: { Ref: "AWS::StackName" } },
+      Resources: { MyQueue: { Type: "AWS::SQS::Queue" } },
+    };
+    const ir = parser.parse(JSON.stringify(original));
+    expect(ir.warnings).toBeUndefined();
+    const { template } = await roundTrip(JSON.stringify(original));
+    expect(template.Description).toBe(original.Description);
+    expect(template.Metadata).toEqual(original.Metadata);
+  });
+
+  test("parameter constraints come back as written", async () => {
+    const original = {
+      Parameters: {
+        Name: {
+          Type: "String",
+          AllowedPattern: "[a-z]+",
+          ConstraintDescription: "lower case",
+          MinLength: "1",
+          MaxLength: 64,
+          NoEcho: true,
+        },
+        Size: { Type: "Number", Default: 5, MinValue: 1, MaxValue: "10", AllowedValues: [1, 5, 10] },
+      },
+      Resources: { MyQueue: { Type: "AWS::SQS::Queue", Properties: { QueueName: { Ref: "Name" }, DelaySeconds: { Ref: "Size" } } } },
+    };
+    const { template } = await roundTrip(JSON.stringify(original));
+    expect(template.Parameters).toEqual(original.Parameters);
+  });
+
+  test("Fn::Select of a list parameter selects from the list, and the index is kept as written", async () => {
+    const original = {
+      Parameters: { Subnets: { Type: "List<AWS::EC2::Subnet::Id>" } },
+      Resources: {
+        MyInstance: { Type: "AWS::EC2::Instance", Properties: { SubnetId: { "Fn::Select": [0, { Ref: "Subnets" }] } } },
+        MyOther: {
+          Type: "AWS::EC2::Instance",
+          Properties: { SubnetId: { "Fn::Select": ["1", { Ref: "Subnets" }] }, AvailabilityZone: { "Fn::Select": [0, { "Fn::GetAZs": "" }] } },
+        },
+      },
+    };
+    const { template } = await roundTrip(JSON.stringify(original));
+    expect(template.Resources).toEqual(original.Resources);
+  });
+
+  test("a logical id that is a class name keeps its name", async () => {
+    const original = {
+      Resources: {
+        InternetGateway: { Type: "AWS::EC2::InternetGateway" },
+        Attachment: {
+          Type: "AWS::EC2::VPCGatewayAttachment",
+          Properties: { InternetGatewayId: { Ref: "InternetGateway" }, VpcId: "vpc-1" },
+        },
+      },
+    };
+    const { template, source } = await roundTrip(JSON.stringify(original));
+    expect(source).toContain("InternetGateway as InternetGatewayResource");
+    expect(template.Resources).toEqual(original.Resources);
+  });
+});
+
+describe("one name in two CloudFormation namespaces", () => {
+  test("an output named like a parameter or a resource, and a condition named like a parameter, come back under their names", async () => {
+    const original = {
+      Parameters: {
+        QueueName: { Type: "String" },
+        EnableReplica: { Type: "String", Default: "false" },
+      },
+      Conditions: {
+        EnableReplica: { "Fn::Equals": [{ Ref: "EnableReplica" }, "true"] },
+      },
+      Resources: {
+        MyQueue: { Type: "AWS::SQS::Queue", Properties: { QueueName: { Ref: "QueueName" } } },
+        Replica: {
+          Type: "AWS::SQS::Queue",
+          Condition: "EnableReplica",
+          Properties: { DelaySeconds: { "Fn::If": ["EnableReplica", 5, 0] } },
+        },
+      },
+      Outputs: {
+        QueueName: { Value: { "Fn::GetAtt": ["MyQueue", "QueueName"] } },
+        MyQueue: { Value: { Ref: "MyQueue" }, Condition: "EnableReplica" },
+      },
+    };
+    const { template, source } = await roundTrip(JSON.stringify(original));
+    expect(source).toContain('export const EnableReplicaCondition = new Condition(');
+    expect(source).toContain('name: "EnableReplica" })');
+    expect(source).toContain("export const QueueNameOutput = stackOutput(");
+    expect(source).toContain("export const MyQueueOutput = stackOutput(");
+    expect(template.Parameters).toEqual(original.Parameters);
+    expect(template.Conditions).toEqual(original.Conditions);
+    expect(template.Resources).toEqual(original.Resources);
+    expect(template.Outputs).toEqual(original.Outputs);
+  });
+});
+
+describe("Mappings and Fn::FindInMap", () => {
+  test("a template's Mappings, and FindInMap reads of them, come back", async () => {
+    const original = {
+      Parameters: { InstanceType: { Type: "String", Default: "t3.micro" } },
+      Mappings: {
+        RegionMap: { "us-east-1": { AZs: ["us-east-1a", "us-east-1b"] } },
+        TypeArch: { "t3.micro": { Arch: "HVM64" } },
+        ArchAmi: { "us-east-1": { HVM64: "ami-123" } },
+      },
+      Resources: {
+        MySubnet: {
+          Type: "AWS::EC2::Subnet",
+          Properties: {
+            VpcId: "vpc-1",
+            CidrBlock: { "Fn::Select": [0, { "Fn::Cidr": ["10.0.0.0/16", 4, 8] }] },
+            AvailabilityZone: { "Fn::Select": [0, { "Fn::FindInMap": ["RegionMap", { Ref: "AWS::Region" }, "AZs"] }] },
+          },
+        },
+        MyInstance: {
+          Type: "AWS::EC2::Instance",
+          Properties: {
+            ImageId: {
+              "Fn::FindInMap": ["ArchAmi", { Ref: "AWS::Region" }, { "Fn::FindInMap": ["TypeArch", { Ref: "InstanceType" }, "Arch"] }],
+            },
+            SubnetId: { "Fn::ImportValue": { "Fn::Sub": "${AWS::StackName}-SubnetId" } },
+          },
+        },
+      },
+    };
+    const ir = parser.parse(JSON.stringify(original));
+    expect(ir.warnings).toBeUndefined();
+    const { template, source } = await roundTrip(JSON.stringify(original));
+    expect(source).toContain("export const RegionMap = new Mapping(");
+    expect(source).toContain('FindInMap(ArchAmi, AWS.Region, FindInMap(TypeArch, Ref(InstanceType), "Arch"))');
+    expect(template.Mappings).toEqual(original.Mappings);
+    expect(template.Resources).toEqual(original.Resources);
+  });
+
+  test("a mapping named like a resource keeps its name", async () => {
+    const original = {
+      Mappings: { Config: { a: { b: "queue-name" } } },
+      Resources: {
+        Config: { Type: "AWS::SQS::Queue", Properties: { QueueName: { "Fn::FindInMap": ["Config", "a", "b"] } } },
+      },
+    };
+    const { template, source } = await roundTrip(JSON.stringify(original));
+    expect(source).toContain('export const ConfigMapping = new Mapping(');
+    expect(template.Mappings).toEqual(original.Mappings);
+    expect(template.Resources).toEqual(original.Resources);
+  });
+
+  test("an intrinsic import cannot write is refused at import, not written as an object", () => {
+    const original = {
+      Resources: {
+        MyQueue: { Type: "AWS::SQS::Queue", Properties: { Tags: { "Fn::Transform": { Name: "AWS::Include", Parameters: {} } } } },
+      },
+    };
+    expect(() => generator.generate(parser.parse(JSON.stringify(original)))).toThrow(/cannot generate Fn::Transform/);
+  });
+});

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

@@ -125,7 +125,7 @@ describe("with-conditions.json build roundtrip (#2069)", () => {
     expect(mainFile.content).toContain("new Condition(Equals(Ref(Cutover), \"true\"))");
     expect(mainFile.content).toContain("new Condition(Not(DoCutover))");
     expect(mainFile.content).toContain("{ Condition: DoCutover }");
-    expect(mainFile.content).toContain("stackOutput(Ref(Rule), { condition: DoCutover })");
+    expect(mainFile.content).toContain('stackOutput(Ref(Rule), { condition: DoCutover, lexicon: "aws" })');
 
     const dir = mkdtempSync(join(import.meta.dirname, "../../.roundtrip-tmp-"));
     try {
@@ -154,10 +154,10 @@ describe("with-conditions.json build roundtrip (#2069)", () => {
 
   test("a section import cannot carry is named in a warning, never dropped silently", () => {
     const template = JSON.parse(readFileSync(join(roundtripDir, "with-conditions.json"), "utf-8"));
-    template.Mappings = { RegionMap: { "us-east-1": { AMI: "ami-123" } } };
+    template.Rules = { Region: { Assertions: [{ Assert: { "Fn::Equals": [{ Ref: "AWS::Region" }, "us-east-1"] } }] } };
     const ir = parser.parse(JSON.stringify(template));
     expect(ir.warnings).toEqual([
-      'Template section "Mappings" is not carried by import — it is dropped from the generated source',
+      'Template section "Rules" is not carried by import — it is dropped from the generated source',
     ]);
   });
 });

package/src/index.ts

@@ -3,12 +3,16 @@ export { Parameter } from "./parameter";
 
 // Condition (#2068) — the Conditions-section declarable
 export { Condition, isCondition, CONDITION_ENTITY_TYPE } from "./condition";
+// Mapping — the Mappings-section declarable, read with FindInMap
+export { Mapping, isMapping, MAPPING_ENTITY_TYPE } from "./mapping";
 
 // Default Tags
 export { defaultTags, isDefaultTags, DEFAULT_TAGS_MARKER } from "./default-tags";
 export type { DefaultTags, TagEntry } from "./default-tags";
 export { templateTransform, isTemplateTransform, TEMPLATE_TRANSFORM_MARKER } from "./template-transform";
 export type { TemplateTransform } from "./template-transform";
+export { templateDescription, templateMetadata, isTemplateSection, TEMPLATE_SECTION_MARKER } from "./template-sections";
+export type { TemplateSection } from "./template-sections";
 
 // Effect receipts (#1835, epic #1703): the aws materialization row
 // (`AWS::SSM::Parameter`, plain String, path derived from the ownership
@@ -125,6 +129,12 @@ export {
   AndIntrinsic,
   OrIntrinsic,
   NotIntrinsic,
+  FindInMap,
+  FindInMapIntrinsic,
+  ImportValue,
+  ImportValueIntrinsic,
+  Cidr,
+  CidrIntrinsic,
 } from "./intrinsics";
 export type { ConditionOperand } from "./intrinsics";
 

package/src/intrinsics.test.ts

@@ -137,13 +137,18 @@ describe("Join intrinsic", () => {
 describe("Select intrinsic", () => {
   test("selects from array", () => {
     const result = Select(0, ["a", "b", "c"]);
-    expect(result.toJSON()).toEqual({ "Fn::Select": ["0", ["a", "b", "c"]] });
+    expect(result.toJSON()).toEqual({ "Fn::Select": [0, ["a", "b", "c"]] });
+  });
+
+  test("keeps the index as written, number or string", () => {
+    expect(Select("0", ["a"]).toJSON()).toEqual({ "Fn::Select": ["0", ["a"]] });
+    expect(Select(2, Ref("Subnets")).toJSON()).toEqual({ "Fn::Select": [2, { Ref: "Subnets" }] });
   });
 
   test("selects with intrinsic array", () => {
     const result = Select(1, [Ref("A"), Ref("B")]);
     expect(result.toJSON()).toEqual({
-      "Fn::Select": ["1", [{ Ref: "A" }, { Ref: "B" }]],
+      "Fn::Select": [1, [{ Ref: "A" }, { Ref: "B" }]],
     });
   });
 });