@intentius/chant 0.18.14 → 0.18.16

package/dist/lexicon-output.d.ts

@@ -1,5 +1,20 @@
 import { INTRINSIC_MARKER, type Intrinsic } from "./intrinsic.js";
 import { AttrRef } from "./attrref.js";
+/**
+ * Sanitize auto-generated Output name parts into a valid CloudFormation
+ * logical id. Real CloudFormation logical ids (including `Outputs` keys)
+ * must match `^[A-Za-z0-9]+$` — no dots, underscores, or other punctuation.
+ *
+ * Splits every part on runs of non-alphanumeric characters (dots from a
+ * nested `Fn::GetAtt` attribute path, underscores, hyphens, etc.) and
+ * re-joins the resulting segments in camelCase. This keeps the id
+ * deterministic and unique per (entityName, attribute) pair while
+ * discarding only punctuation — no information is lost, so two distinct
+ * inputs only collide if they already differ solely by punctuation.
+ *
+ * @internal
+ */
+export declare function sanitizeLogicalId(...parts: string[]): string;
 /**
  * Represents a cross-lexicon output that bridges a producing lexicon (e.g. AWS)
  * with any consuming lexicon (e.g. GitHub, Cloudflare).
@@ -36,9 +51,14 @@ export declare class LexiconOutput implements Intrinsic {
      * Create a LexiconOutput with an auto-generated name from entity name and attribute.
      * Used during cross-lexicon ref auto-detection.
      *
+     * The name is sanitized to a valid CloudFormation logical id (see
+     * {@link sanitizeLogicalId}) since it is used verbatim as the `Outputs`
+     * key by lexicon serializers (e.g. AWS CloudFormation), which reject
+     * dots or underscores in logical ids.
+     *
      * @param ref - The AttrRef pointing to the source entity
      * @param entityName - The logical name of the source entity
-     * @returns A LexiconOutput with name `{entityName}_{attribute}`
+     * @returns A LexiconOutput with a name derived from `{entityName}{Attribute}`
      */
     static auto(ref: AttrRef, entityName: string): LexiconOutput;
     toJSON(): {

package/dist/lexicon-output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lexicon-output.d.ts","sourceRoot":"","sources":["../src/lexicon-output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;;;;GAQG;AACH,qBAAa,aAAc,YAAW,SAAS;IAC7C,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAG,IAAI,CAAU;IAC5C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAC/C,uFAAuF;IACvF,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;gBAElC,GAAG,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM;IA8B3D;;;;OAIG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIpC;;;;OAIG;IACH,cAAc,IAAI,OAAO;IAOzB;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,aAAa;IAO5D,MAAM,IAAI;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE;CAGtC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAErF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE"}
+{"version":3,"file":"lexicon-output.d.ts","sourceRoot":"","sources":["../src/lexicon-output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAW5D;AAED;;;;;;;;GAQG;AACH,qBAAa,aAAc,YAAW,SAAS;IAC7C,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAG,IAAI,CAAU;IAC5C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAC/C,uFAAuF;IACvF,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;gBAElC,GAAG,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM;IA8B3D;;;;OAIG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIpC;;;;OAIG;IACH,cAAc,IAAI,OAAO;IAOzB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,aAAa;IAO5D,MAAM,IAAI;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE;CAGtC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAErF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.18.14",
+  "version": "0.18.16",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/build.test.ts

@@ -323,7 +323,8 @@ describe("detectCrossLexiconRefs", () => {
     expect(detected[0].sourceLexicon).toBe("alpha");
     expect(detected[0].sourceEntity).toBe("dataBucket");
     expect(detected[0].sourceAttribute).toBe("Endpoint");
-    expect(detected[0].outputName).toBe("dataBucket_Endpoint");
+    expect(detected[0].outputName).toBe("dataBucketEndpoint");
+    expect(detected[0].outputName).toMatch(/^[A-Za-z0-9]+$/);
   });
 
   test("explicit output() overrides auto-detected name", () => {
@@ -351,7 +352,7 @@ describe("detectCrossLexiconRefs", () => {
     // Auto-detect finds the cross-lexicon ref
     const autoDetected = detectCrossLexiconRefs(entities);
     expect(autoDetected).toHaveLength(1);
-    expect(autoDetected[0].outputName).toBe("dataBucket_Arn");
+    expect(autoDetected[0].outputName).toBe("dataBucketArn");
 
     // But when collecting explicit outputs, the explicit one is found
     const explicitOutputs = collectLexiconOutputs(entities);
@@ -459,7 +460,44 @@ describe("detectCrossLexiconRefs", () => {
 
     const detected = detectCrossLexiconRefs(entities);
     expect(detected).toHaveLength(1);
-    expect(detected[0].outputName).toBe("dataBucket_Endpoint");
+    expect(detected[0].outputName).toBe("dataBucketEndpoint");
+  });
+
+  // chant#930 — a nested Fn::GetAtt attribute path (dots) on a cross-lexicon
+  // ref must not leak into the auto-generated Output logical id: CFN logical
+  // ids (including Outputs keys) are alphanumeric-only (^[A-Za-z0-9]+$), and
+  // cfn-lint (E6001) rejects anything else.
+  test("auto-generated Output logical id is valid CFN form for a nested attribute path", () => {
+    const alphaBucket = {
+      lexicon: "alpha",
+      entityType: "Alpha::Storage::Bucket",
+      [DECLARABLE_MARKER]: true,
+    } as Declarable;
+
+    const nestedRef = new AttrRef(
+      alphaBucket,
+      "MetadataConfiguration.AnnotationTableConfiguration.TableArn"
+    );
+
+    const ghAction = {
+      lexicon: "github",
+      entityType: "Action",
+      [DECLARABLE_MARKER]: true,
+      props: { arn: nestedRef },
+    } as unknown as Declarable;
+
+    const entities = new Map<string, Declarable>([
+      ["foundationArtifactBucket", alphaBucket],
+      ["deployAction", ghAction],
+    ]);
+
+    const detected = detectCrossLexiconRefs(entities);
+
+    expect(detected).toHaveLength(1);
+    expect(detected[0].outputName).toMatch(/^[A-Za-z0-9]+$/);
+    expect(detected[0].outputName).toBe(
+      "foundationArtifactBucketMetadataConfigurationAnnotationTableConfigurationTableArn"
+    );
   });
 });
 

package/src/lexicon-output.test.ts

@@ -100,18 +100,18 @@ describe("LexiconOutput.auto", () => {
     const result = LexiconOutput.auto(bucket.arn, "dataBucket");
 
     expect(result).toBeInstanceOf(LexiconOutput);
-    expect(result.outputName).toBe("dataBucket_Arn");
+    expect(result.outputName).toBe("dataBucketArn");
     expect(result.sourceLexicon).toBe("testdom");
     expect(result.sourceEntity).toBe("dataBucket");
     expect(result.sourceAttribute).toBe("Arn");
   });
 
-  test("auto-generated name follows {entityName}_{attribute} pattern", () => {
+  test("auto-generated name follows {entityName}{Attribute} camelCase pattern", () => {
     const bucket = new MockResource();
     const endpointRef = new AttrRef(bucket, "Endpoint");
     const result = LexiconOutput.auto(endpointRef, "myBucket");
 
-    expect(result.outputName).toBe("myBucket_Endpoint");
+    expect(result.outputName).toBe("myBucketEndpoint");
   });
 
   test("sets sourceEntity immediately", () => {
@@ -121,6 +121,37 @@ describe("LexiconOutput.auto", () => {
     // sourceEntity should be set right away, not empty
     expect(result.sourceEntity).toBe("logsBucket");
   });
+
+  // chant#930 — CFN logical ids (including Outputs keys) must be alphanumeric
+  // only. A nested Fn::GetAtt attribute path (dots) must not leak through.
+  test("sanitizes dotted nested-attribute paths to a valid CFN logical id", () => {
+    const bucket = new MockResource();
+    const nestedRef = new AttrRef(
+      bucket,
+      "MetadataConfiguration.AnnotationTableConfiguration.TableArn"
+    );
+    const result = LexiconOutput.auto(nestedRef, "foundationArtifactBucket");
+
+    expect(result.outputName).toMatch(/^[A-Za-z0-9]+$/);
+    expect(result.outputName).toBe(
+      "foundationArtifactBucketMetadataConfigurationAnnotationTableConfigurationTableArn"
+    );
+  });
+
+  test("auto-generated output names are always valid CFN logical ids", () => {
+    const bucket = new MockResource();
+    const cases: Array<[string, string]> = [
+      ["dataBucket", "Arn"],
+      ["my-bucket_2", "Some.Nested.Attr"],
+      ["logsBucket", "Endpoint.Hostname"],
+    ];
+
+    for (const [entityName, attribute] of cases) {
+      const ref = new AttrRef(bucket, attribute);
+      const result = LexiconOutput.auto(ref, entityName);
+      expect(result.outputName).toMatch(/^[A-Za-z0-9]+$/);
+    }
+  });
 });
 
 describe("output() helper", () => {

package/src/lexicon-output.ts

@@ -1,6 +1,33 @@
 import { INTRINSIC_MARKER, type Intrinsic } from "./intrinsic";
 import { AttrRef } from "./attrref";
 
+/**
+ * Sanitize auto-generated Output name parts into a valid CloudFormation
+ * logical id. Real CloudFormation logical ids (including `Outputs` keys)
+ * must match `^[A-Za-z0-9]+$` — no dots, underscores, or other punctuation.
+ *
+ * Splits every part on runs of non-alphanumeric characters (dots from a
+ * nested `Fn::GetAtt` attribute path, underscores, hyphens, etc.) and
+ * re-joins the resulting segments in camelCase. This keeps the id
+ * deterministic and unique per (entityName, attribute) pair while
+ * discarding only punctuation — no information is lost, so two distinct
+ * inputs only collide if they already differ solely by punctuation.
+ *
+ * @internal
+ */
+export function sanitizeLogicalId(...parts: string[]): string {
+  const segments = parts
+    .join("_")
+    .split(/[^A-Za-z0-9]+/)
+    .filter((segment) => segment.length > 0);
+
+  if (segments.length === 0) return "Output";
+
+  return segments
+    .map((segment, i) => (i === 0 ? segment : segment.charAt(0).toUpperCase() + segment.slice(1)))
+    .join("");
+}
+
 /**
  * Represents a cross-lexicon output that bridges a producing lexicon (e.g. AWS)
  * with any consuming lexicon (e.g. GitHub, Cloudflare).
@@ -76,12 +103,17 @@ export class LexiconOutput implements Intrinsic {
    * Create a LexiconOutput with an auto-generated name from entity name and attribute.
    * Used during cross-lexicon ref auto-detection.
    *
+   * The name is sanitized to a valid CloudFormation logical id (see
+   * {@link sanitizeLogicalId}) since it is used verbatim as the `Outputs`
+   * key by lexicon serializers (e.g. AWS CloudFormation), which reject
+   * dots or underscores in logical ids.
+   *
    * @param ref - The AttrRef pointing to the source entity
    * @param entityName - The logical name of the source entity
-   * @returns A LexiconOutput with name `{entityName}_{attribute}`
+   * @returns A LexiconOutput with a name derived from `{entityName}{Attribute}`
    */
   static auto(ref: AttrRef, entityName: string): LexiconOutput {
-    const name = `${entityName}_${ref.attribute}`;
+    const name = sanitizeLogicalId(entityName, ref.attribute);
     const output = new LexiconOutput(ref, name);
     output._setSourceEntity(entityName);
     return output;