@intentius/chant-lexicon-aws 0.0.12 → 0.0.13

package/src/index.ts

@@ -77,12 +77,12 @@ export {
   LambdaApi,
   LambdaScheduled, ScheduledLambda,
   LambdaSqs, LambdaEventBridge, LambdaDynamoDB, LambdaS3, LambdaSns,
-  VpcDefault, FargateAlb, AlbShared, FargateService,
+  VpcDefault, FargateAlb, AlbShared, FargateService, RdsInstance, RdsPostgres,
 } from "./composites/index";
 export type {
   LambdaFunctionProps, LambdaApiProps, ScheduledLambdaProps,
   LambdaSqsProps, LambdaEventBridgeProps, LambdaDynamoDBProps, LambdaS3Props, LambdaSnsProps,
-  VpcDefaultProps, FargateAlbProps, AlbSharedProps, FargateServiceProps,
+  VpcDefaultProps, FargateAlbProps, AlbSharedProps, FargateServiceProps, RdsInstanceProps, RdsPostgresProps,
 } from "./composites/index";
 
 // Code generation pipeline

package/src/spec/parse.test.ts

@@ -275,6 +275,56 @@ describe("parseCFNSchema", () => {
     const result = parseCFNSchema(schema);
     expect(result.resource.conditionalCreateOnly).toEqual([]);
   });
+
+  // --- Nested readOnlyProperties ---
+
+  test("parses nested readOnlyProperties as flattened dot-separated attrs", () => {
+    const schema = JSON.stringify({
+      typeName: "AWS::RDS::DBInstance",
+      properties: {
+        DBInstanceIdentifier: { type: "string" },
+        Endpoint: { $ref: "#/definitions/Endpoint" },
+      },
+      definitions: {
+        Endpoint: {
+          type: "object",
+          properties: {
+            Address: { type: "string" },
+            Port: { type: "string" },
+            HostedZoneId: { type: "string" },
+          },
+          additionalProperties: false,
+        },
+      },
+      readOnlyProperties: [
+        "/properties/Endpoint",
+        "/properties/Endpoint/Address",
+        "/properties/Endpoint/Port",
+        "/properties/Endpoint/HostedZoneId",
+        "/properties/DBInstanceIdentifier",
+      ],
+      additionalProperties: false,
+    });
+    const result = parseCFNSchema(schema);
+
+    // Should have both top-level and nested attrs
+    const attrNames = result.resource.attributes.map((a) => a.name);
+    expect(attrNames).toContain("Endpoint");
+    expect(attrNames).toContain("Endpoint.Address");
+    expect(attrNames).toContain("Endpoint.Port");
+    expect(attrNames).toContain("Endpoint.HostedZoneId");
+    expect(attrNames).toContain("DBInstanceIdentifier");
+
+    // Top-level Endpoint gets its resolved type from properties
+    const endpoint = result.resource.attributes.find((a) => a.name === "Endpoint");
+    expect(endpoint!.tsType).not.toBe("string"); // Should be a $ref type
+
+    // Nested attrs are always string
+    const address = result.resource.attributes.find((a) => a.name === "Endpoint.Address");
+    expect(address!.tsType).toBe("string");
+    const port = result.resource.attributes.find((a) => a.name === "Endpoint.Port");
+    expect(port!.tsType).toBe("string");
+  });
 });
 
 describe("cfnShortName", () => {

package/src/spec/parse.ts

@@ -93,15 +93,18 @@ export function parseCFNSchema(data: string | Buffer): SchemaParseResult {
   const attrs: ParsedAttribute[] = [];
   for (const path of schema.readOnlyProperties ?? []) {
     const attrName = stripPointerPath(path);
-    // Skip nested paths (contain "/" after stripping prefix, or ".")
-    if (attrName.includes("/") || attrName.includes(".")) continue;
 
-    // Try to find type from properties, default to string
+    // Flatten nested paths: "Endpoint/Address" → attr name "Endpoint.Address"
+    const cfnAttr = attrName.replace(/\//g, ".");
+
     let tsType = "string";
-    if (schema.properties?.[attrName]) {
-      tsType = resolvePropertyType(schema.properties[attrName], schema);
+    // For top-level attrs, look up type from properties
+    if (!cfnAttr.includes(".") && schema.properties?.[cfnAttr]) {
+      tsType = resolvePropertyType(schema.properties[cfnAttr], schema);
     }
-    attrs.push({ name: attrName, tsType });
+    // For nested attrs, type is always string (CF GetAtt returns strings for leaf values)
+
+    attrs.push({ name: cfnAttr, tsType });
   }
 
   // Parse definitions into property types and enums

package/src/validate.test.ts

@@ -0,0 +1,34 @@
+import { describe, test, expect } from "bun:test";
+import { validate } from "./validate";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+const basePath = dirname(dirname(fileURLToPath(import.meta.url)));
+
+describe("validate", () => {
+  test("runs validation checks on current generated artifacts", async () => {
+    const result = await validate({ basePath });
+    expect(result.checks.length).toBeGreaterThan(0);
+  });
+
+  test("checks lexicon JSON exists and parses", async () => {
+    const result = await validate({ basePath });
+    const jsonCheck = result.checks.find((c) => c.name === "lexicon-json-exists");
+    expect(jsonCheck).toBeDefined();
+    expect(jsonCheck?.ok).toBe(true);
+  });
+
+  test("checks types exist", async () => {
+    const result = await validate({ basePath });
+    const typesCheck = result.checks.find((c) => c.name === "types-exist");
+    expect(typesCheck).toBeDefined();
+    expect(typesCheck?.ok).toBe(true);
+  });
+
+  test("checks required names are present", async () => {
+    const result = await validate({ basePath });
+    const requiredCheck = result.checks.find((c) => c.name === "required-names");
+    expect(requiredCheck).toBeDefined();
+    expect(requiredCheck?.ok).toBe(true);
+  });
+});