@intentius/chant-lexicon-aws 0.0.6 → 0.0.8

package/src/import/generator.test.ts

@@ -35,7 +35,7 @@ describe("CFGenerator", () => {
 
     expect(files[0].content).toContain("import { Bucket }");
     expect(files[0].content).toContain("export const MyBucket = new Bucket({");
-    expect(files[0].content).toContain('bucketName: "my-bucket"');
+    expect(files[0].content).toContain('BucketName: "my-bucket"');
   });
 
   test("generates Lambda Function", () => {
@@ -58,8 +58,8 @@ describe("CFGenerator", () => {
 
     expect(files[0].content).toContain("import { Function }");
     expect(files[0].content).toContain("export const MyFunction = new Function({");
-    expect(files[0].content).toContain('functionName: "my-function"');
-    expect(files[0].content).toContain('runtime: "nodejs18.x"');
+    expect(files[0].content).toContain('FunctionName: "my-function"');
+    expect(files[0].content).toContain('Runtime: "nodejs18.x"');
   });
 
   test("generates Ref as variable reference", () => {
@@ -78,7 +78,7 @@ describe("CFGenerator", () => {
 
     const files = generator.generate(ir);
 
-    expect(files[0].content).toContain("bucketName: Ref(BucketName)");
+    expect(files[0].content).toContain("BucketName: Ref(BucketName)");
   });
 
   test("generates GetAtt as property access", () => {
@@ -102,7 +102,7 @@ describe("CFGenerator", () => {
 
     const files = generator.generate(ir);
 
-    expect(files[0].content).toContain("sourceArn: SourceBucket.arn");
+    expect(files[0].content).toContain("SourceArn: SourceBucket.Arn");
   });
 
   test("generates Sub as tagged template", () => {

package/src/import/generator.ts

@@ -1,4 +1,6 @@
+import { createRequire } from "module";
 import type { TemplateIR, ResourceIR, ParameterIR } from "@intentius/chant/import/parser";
+const require = createRequire(import.meta.url);
 import type { TypeScriptGenerator, GeneratedFile } from "@intentius/chant/import/generator";
 import { topoSort } from "@intentius/chant/codegen/topo-sort";
 import { hasIntrinsicInValue, irUsesIntrinsic, collectDependencies } from "@intentius/chant/import/ir-utils";
@@ -455,11 +457,9 @@ export class CFGenerator implements TypeScriptGenerator {
   }
 
   /**
-   * Convert a property name to camelCase (lowercase first char).
-   * Used for resource property access (e.g., GetAtt attribute names)
-   * which matches chant's camelCase property convention.
+   * Property names use spec-native casing (PascalCase for CloudFormation).
    */
   private toPropName(name: string): string {
-    return name.charAt(0).toLowerCase() + name.slice(1);
+    return name;
   }
 }

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

@@ -5,7 +5,8 @@ import { CFParser } from "./parser";
 import { CFGenerator } from "./generator";
 import { build } from "@intentius/chant/build";
 import { awsSerializer } from "../serializer";
-import * as awsLexicon from "../index";
+// Dynamic import to get all export keys for validation (not a runtime barrel import)
+const awsLexicon = await import("../index");
 
 const parser = new CFParser();
 const generator = new CFGenerator();

package/src/import/roundtrip.test.ts

@@ -24,7 +24,7 @@ describe("CloudFormation round-trip", () => {
     const files = generator.generate(ir);
 
     expect(files[0].content).toContain("Bucket");
-    expect(files[0].content).toContain('bucketName: "my-bucket"');
+    expect(files[0].content).toContain('BucketName: "my-bucket"');
     expect(files[0].content).toContain("export const MyBucket");
   });
 
@@ -53,7 +53,7 @@ describe("CloudFormation round-trip", () => {
 
     expect(files[0].content).toContain("Parameter");
     expect(files[0].content).toContain("Environment");
-    expect(files[0].content).toContain("bucketName: Ref(Environment)");
+    expect(files[0].content).toContain("BucketName: Ref(Environment)");
   });
 
   test("round-trips template with Fn::Sub", () => {
@@ -115,7 +115,7 @@ describe("CloudFormation round-trip", () => {
 
     expect(files[0].content).toContain("Role");
     expect(files[0].content).toContain("Function");
-    expect(files[0].content).toContain("LambdaRole.arn");
+    expect(files[0].content).toContain("LambdaRole.Arn");
   });
 
   test("round-trips complex nested properties", () => {
@@ -148,8 +148,8 @@ describe("CloudFormation round-trip", () => {
     const files = generator.generate(ir);
 
     expect(files[0].content).toContain("Function");
-    expect(files[0].content).toContain("environment:");
-    expect(files[0].content).toContain("vpcConfig:");
+    expect(files[0].content).toContain("Environment:");
+    expect(files[0].content).toContain("VpcConfig:");
   });
 
   test("round-trips empty template", () => {

package/src/integration.test.ts

@@ -17,7 +17,7 @@ describe("AWS Integration", () => {
 
     test("serializes S3 bucket with properties", () => {
       const bucket = new (Bucket as any)({
-        bucketName: "my-bucket",
+        BucketName: "my-bucket",
       });
 
       const entities = new Map<string, Declarable>();
@@ -61,12 +61,12 @@ describe("AWS Integration", () => {
 
   describe("Cross-resource references", () => {
     test("GetAtt for bucket ARN", () => {
-      const bucket = new (Bucket as any)({ bucketName: "source" });
+      const bucket = new (Bucket as any)({ BucketName: "source" });
       // Set logical name for the AttrRef
-      (bucket.arn as Record<string, unknown>)._setLogicalName("SourceBucket");
+      (bucket.Arn as Record<string, unknown>)._setLogicalName("SourceBucket");
 
-      expect(bucket.arn.getLogicalName()).toBe("SourceBucket");
-      expect(bucket.arn.attribute).toBe("Arn");
+      expect(bucket.Arn.getLogicalName()).toBe("SourceBucket");
+      expect(bucket.Arn.attribute).toBe("Arn");
     });
   });
 
@@ -79,10 +79,10 @@ describe("AWS Integration", () => {
 
     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",
+        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);
@@ -90,7 +90,7 @@ describe("AWS Integration", () => {
 
     test("IAM Role has correct entity type", () => {
       const role = new (Role as any)({
-        assumeRolePolicyDocument: {
+        AssumeRolePolicyDocument: {
           Version: "2012-10-17",
           Statement: [],
         },
@@ -103,27 +103,27 @@ describe("AWS Integration", () => {
   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();
+      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",
+        Runtime: "nodejs18.x",
+        Handler: "index.handler",
+        Code: { S3Bucket: "bucket", S3Key: "key" },
+        Role: "role-arn",
       });
-      expect(fn.arn).toBeDefined();
+      expect(fn.Arn).toBeDefined();
     });
 
     test("IAM Role has expected AttrRefs", () => {
       const role = new (Role as any)({
-        assumeRolePolicyDocument: {},
+        AssumeRolePolicyDocument: {},
       });
-      expect(role.arn).toBeDefined();
-      expect(role.roleId).toBeDefined();
+      expect(role.Arn).toBeDefined();
+      expect(role.RoleId).toBeDefined();
     });
   });
 });

package/src/lint/post-synth/ext001.ts

@@ -11,6 +11,8 @@
  * - required_xor: exactly one of the listed properties must exist
  */
 
+import { readFileSync } from "fs";
+import { join } from "path";
 import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
 import { parseCFTemplate, type CFResource } from "./cf-refs";
 
@@ -34,10 +36,6 @@ interface LexiconEntry {
 function loadLexiconConstraints(): Map<string, ExtensionConstraint[]> {
   const map = new Map<string, ExtensionConstraint[]>();
   try {
-    const { readFileSync } = require("fs");
-    const { join, dirname } = require("path");
-    const { fileURLToPath } = require("url");
-
     // Navigate from src/lint/post-synth/ up to the package root
     const pkgDir = join(__dirname, "..", "..", "..");
     const lexiconPath = join(pkgDir, "src", "generated", "lexicon-aws.json");

package/src/lint/rules/rules.test.ts

@@ -65,7 +65,7 @@ describe("AWS Lint Rules", () => {
   describe("WAW006: S3 Encryption", () => {
     test("warns on Bucket without encryption", () => {
       const context = createContext(`
-        const bucket = new Bucket({ bucketName: "my-bucket" });
+        const bucket = new Bucket({ BucketName: "my-bucket" });
       `);
       const diagnostics = s3EncryptionRule.check(context);
       expect(diagnostics).toHaveLength(1);
@@ -73,22 +73,22 @@ describe("AWS Lint Rules", () => {
       expect(diagnostics[0].message).toContain("encryption");
     });
 
-    test("passes with bucketEncryption property", () => {
+    test("passes with BucketEncryption property", () => {
       const context = createContext(`
         const bucket = new Bucket({
-          bucketName: "my-bucket",
-          bucketEncryption: { serverSideEncryptionConfiguration: [] },
+          BucketName: "my-bucket",
+          BucketEncryption: { ServerSideEncryptionConfiguration: [] },
         });
       `);
       const diagnostics = s3EncryptionRule.check(context);
       expect(diagnostics).toHaveLength(0);
     });
 
-    test("passes with encryption property", () => {
+    test("passes with ServerSideEncryptionConfiguration property", () => {
       const context = createContext(`
         const bucket = new Bucket({
-          bucketName: "my-bucket",
-          encryption: "AES256",
+          BucketName: "my-bucket",
+          ServerSideEncryptionConfiguration: [],
         });
       `);
       const diagnostics = s3EncryptionRule.check(context);
@@ -97,7 +97,7 @@ describe("AWS Lint Rules", () => {
 
     test("ignores non-Bucket constructors", () => {
       const context = createContext(`
-        const fn = new Function({ functionName: "my-fn" });
+        const fn = new Function({ FunctionName: "my-fn" });
       `);
       const diagnostics = s3EncryptionRule.check(context);
       expect(diagnostics).toHaveLength(0);

package/src/lint/rules/s3-encryption.ts

@@ -38,9 +38,8 @@ export const s3EncryptionRule: LintRule = {
           if (ts.isObjectLiteralExpression(props)) {
             const hasEncryption = props.properties.some((prop) => {
               if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
-                return prop.name.text === "bucketEncryption" ||
-                       prop.name.text === "encryption" ||
-                       prop.name.text === "serverSideEncryptionConfiguration";
+                return prop.name.text === "BucketEncryption" ||
+                       prop.name.text === "ServerSideEncryptionConfiguration";
               }
               return false;
             });

package/src/lsp/completions.ts

@@ -1,5 +1,7 @@
+import { createRequire } from "module";
 import type { CompletionContext, CompletionItem } from "@intentius/chant/lsp/types";
 import { LexiconIndex, lexiconCompletions, type LexiconEntry } from "@intentius/chant/lsp/lexicon-providers";
+const require = createRequire(import.meta.url);
 
 let cachedIndex: LexiconIndex | null = null;
 

package/src/lsp/hover.ts

@@ -1,5 +1,7 @@
+import { createRequire } from "module";
 import type { HoverContext, HoverInfo } from "@intentius/chant/lsp/types";
 import { LexiconIndex, lexiconHover, type LexiconEntry } from "@intentius/chant/lsp/lexicon-providers";
+const require = createRequire(import.meta.url);
 
 let cachedIndex: LexiconIndex | null = null;
 

package/src/nested-stack.ts

@@ -85,7 +85,7 @@ export function isNestedStackInstance(value: unknown): value is NestedStackInsta
  *
  * @example
  * ```ts
- * const network = _.nestedStack("network", import.meta.dir + "/network", {
+ * const network = _.nestedStack("network", import.meta.dirname + "/network", {
  *   parameters: { Environment: "prod" },
  * });
  *

package/src/plugin.test.ts

@@ -96,17 +96,17 @@ describe("awsPlugin", () => {
       expect(skills.length).toBeGreaterThanOrEqual(1);
     });
 
-    test("aws-cloudformation skill has required fields", () => {
+    test("chant-aws skill has required fields", () => {
       const skills = awsPlugin.skills!();
-      const cfnSkill = skills.find((s) => s.name === "aws-cloudformation");
+      const cfnSkill = skills.find((s) => s.name === "chant-aws");
       expect(cfnSkill).toBeDefined();
       expect(cfnSkill!.description.length).toBeGreaterThan(0);
       expect(cfnSkill!.content.length).toBeGreaterThan(0);
     });
 
-    test("aws-cloudformation skill has triggers", () => {
+    test("chant-aws skill has triggers", () => {
       const skills = awsPlugin.skills!();
-      const cfnSkill = skills.find((s) => s.name === "aws-cloudformation")!;
+      const cfnSkill = skills.find((s) => s.name === "chant-aws")!;
       expect(cfnSkill.triggers).toBeDefined();
       expect(cfnSkill.triggers!.length).toBeGreaterThanOrEqual(1);
 
@@ -119,9 +119,9 @@ describe("awsPlugin", () => {
       expect(contextTrigger!.value).toBe("aws");
     });
 
-    test("aws-cloudformation skill has parameters", () => {
+    test("chant-aws skill has parameters", () => {
       const skills = awsPlugin.skills!();
-      const cfnSkill = skills.find((s) => s.name === "aws-cloudformation")!;
+      const cfnSkill = skills.find((s) => s.name === "chant-aws")!;
       expect(cfnSkill.parameters).toBeDefined();
       expect(cfnSkill.parameters!.length).toBeGreaterThanOrEqual(1);
 
@@ -131,9 +131,9 @@ describe("awsPlugin", () => {
       expect(resourceTypeParam!.type).toBe("string");
     });
 
-    test("aws-cloudformation skill has examples", () => {
+    test("chant-aws skill has examples", () => {
       const skills = awsPlugin.skills!();
-      const cfnSkill = skills.find((s) => s.name === "aws-cloudformation")!;
+      const cfnSkill = skills.find((s) => s.name === "chant-aws")!;
       expect(cfnSkill.examples).toBeDefined();
       expect(cfnSkill.examples!.length).toBeGreaterThanOrEqual(1);
 
@@ -145,11 +145,12 @@ describe("awsPlugin", () => {
 
     test("skill content is valid markdown with frontmatter", () => {
       const skills = awsPlugin.skills!();
-      const cfnSkill = skills.find((s) => s.name === "aws-cloudformation")!;
+      const cfnSkill = skills.find((s) => s.name === "chant-aws")!;
       expect(cfnSkill.content).toContain("---");
-      expect(cfnSkill.content).toContain("# AWS CloudFormation with Chant");
-      expect(cfnSkill.content).toContain("## Common Resource Types");
-      expect(cfnSkill.content).toContain("## Best Practices");
+      expect(cfnSkill.content).toContain("skill: chant-aws");
+      expect(cfnSkill.content).toContain("user-invocable: true");
+      expect(cfnSkill.content).toContain("chant build");
+      expect(cfnSkill.content).toContain("aws cloudformation deploy");
     });
   });
 
@@ -174,9 +175,6 @@ describe("awsPlugin", () => {
       expect(typeof awsPlugin.package).toBe("function");
     });
 
-    test("rollback is a function", () => {
-      expect(typeof awsPlugin.rollback).toBe("function");
-    });
   });
 
   // -----------------------------------------------------------------------